dlls/quartz/dsoundrender.c

   1 /*
   2  * Direct Sound Audio Renderer
   3  *
   4  * Copyright 2004 Christian Costa
   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 "config.h"
  22
  23 #include "quartz_private.h"
  24 #include "pin.h"
  25
  26 #include "uuids.h"
  27 #include "vfwmsgs.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "dshow.h"
  31 #include "evcode.h"
  32 #include "strmif.h"
  33 #include "dsound.h"
  34 #include "amaudio.h"
  35
  36 #include "wine/unicode.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  40
  41 /* NOTE: buffer can still be filled completely,
  42  * but we start waiting until only this amount is buffered
  43  */
  44 static const REFERENCE_TIME DSoundRenderer_Max_Fill = 150 * 10000;
  45
  46 static const IBaseFilterVtbl DSoundRender_Vtbl;
  47 static const IBasicAudioVtbl IBasicAudio_Vtbl;
  48 static const IReferenceClockVtbl IReferenceClock_Vtbl;
  49 static const IMediaSeekingVtbl IMediaSeeking_Vtbl;
  50 static const IAMDirectSoundVtbl IAMDirectSound_Vtbl;
  51 static const IAMFilterMiscFlagsVtbl IAMFilterMiscFlags_Vtbl;
  52
  53 typedef struct DSoundRenderImpl
  54 {
  55     BaseRenderer renderer;
  56
  57     const IBasicAudioVtbl *IBasicAudio_vtbl;
  58     const IReferenceClockVtbl *IReferenceClock_vtbl;
  59     const IAMDirectSoundVtbl *IAMDirectSound_vtbl;
  60     const IAMFilterMiscFlagsVtbl *IAMFilterMiscFlags_vtbl;
  61
  62     IDirectSound8 *dsound;
  63     LPDIRECTSOUNDBUFFER dsbuffer;
  64     DWORD buf_size;
  65     DWORD in_loop;
  66     DWORD last_playpos, writepos;
  67
  68     REFERENCE_TIME play_time;
  69
  70     HANDLE blocked;
  71
  72     LONG volume;
  73     LONG pan;
  74
  75     DWORD threadid;
  76     HANDLE advisethread, thread_wait;
  77 } DSoundRenderImpl;
  78
  79 static inline DSoundRenderImpl *impl_from_BaseRenderer(BaseRenderer *iface)
  80 {
  81     return CONTAINING_RECORD(iface, DSoundRenderImpl, renderer);
  82 }
  83
  84 static inline DSoundRenderImpl *impl_from_IBaseFilter(IBaseFilter *iface)
  85 {
  86     return CONTAINING_RECORD(iface, DSoundRenderImpl, renderer.filter.IBaseFilter_iface);
  87 }
  88
  89 static REFERENCE_TIME time_from_pos(DSoundRenderImpl *This, DWORD pos) {
  90     WAVEFORMATEX *wfx = (WAVEFORMATEX*)This->renderer.pInputPin->pin.mtCurrent.pbFormat;
  91     REFERENCE_TIME ret = 10000000;
  92     ret = ret * pos / wfx->nAvgBytesPerSec;
  93     return ret;
  94 }
  95
  96 static DWORD pos_from_time(DSoundRenderImpl *This, REFERENCE_TIME time) {
  97     WAVEFORMATEX *wfx = (WAVEFORMATEX*)This->renderer.pInputPin->pin.mtCurrent.pbFormat;
  98     REFERENCE_TIME ret = time;
  99     ret *= wfx->nSamplesPerSec;
 100     ret /= 10000000;
 101     ret *= wfx->nBlockAlign;
 102     return ret;
 103 }
 104
 105 static void DSoundRender_UpdatePositions(DSoundRenderImpl *This, DWORD *seqwritepos, DWORD *minwritepos) {
 106     WAVEFORMATEX *wfx = (WAVEFORMATEX*)This->renderer.pInputPin->pin.mtCurrent.pbFormat;
 107     BYTE *buf1, *buf2;
 108     DWORD size1, size2, playpos, writepos, old_writepos, old_playpos, adv;
 109     BOOL writepos_set = This->writepos < This->buf_size;
 110
 111     /* Update position and zero */
 112     old_writepos = This->writepos;
 113     old_playpos = This->last_playpos;
 114     if (old_writepos <= old_playpos)
 115         old_writepos += This->buf_size;
 116
 117     IDirectSoundBuffer_GetCurrentPosition(This->dsbuffer, &playpos, &writepos);
 118     if (old_playpos > playpos) {
 119         adv = This->buf_size + playpos - old_playpos;
 120         This->play_time += time_from_pos(This, This->buf_size);
 121     } else
 122         adv = playpos - old_playpos;
 123     This->last_playpos = playpos;
 124     if (adv) {
 125         TRACE("Moving from %u to %u: clearing %u bytes\n", old_playpos, playpos, adv);
 126         IDirectSoundBuffer_Lock(This->dsbuffer, old_playpos, adv, (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
 127         memset(buf1, wfx->wBitsPerSample == 8 ? 128  : 0, size1);
 128         memset(buf2, wfx->wBitsPerSample == 8 ? 128  : 0, size2);
 129         IDirectSoundBuffer_Unlock(This->dsbuffer, buf1, size1, buf2, size2);
 130     }
 131     *minwritepos = writepos;
 132     if (!writepos_set || old_writepos < writepos) {
 133         if (writepos_set) {
 134             This->writepos = This->buf_size;
 135             FIXME("Underrun of data occurred!\n");
 136         }
 137         *seqwritepos = writepos;
 138     } else
 139         *seqwritepos = This->writepos;
 140 }
 141
 142 static HRESULT DSoundRender_GetWritePos(DSoundRenderImpl *This, DWORD *ret_writepos, REFERENCE_TIME write_at, DWORD *pfree, DWORD *skip)
 143 {
 144     WAVEFORMATEX *wfx = (WAVEFORMATEX*)This->renderer.pInputPin->pin.mtCurrent.pbFormat;
 145     DWORD writepos, min_writepos, playpos;
 146     REFERENCE_TIME max_lag = 50 * 10000;
 147     REFERENCE_TIME min_lag = 25 * 10000;
 148     REFERENCE_TIME cur, writepos_t, delta_t;
 149
 150     DSoundRender_UpdatePositions(This, &writepos, &min_writepos);
 151     playpos = This->last_playpos;
 152     if (This->renderer.filter.pClock == (IReferenceClock*)&This->IReferenceClock_vtbl) {
 153         max_lag = min_lag;
 154         cur = This->play_time + time_from_pos(This, playpos);
 155         cur -= This->renderer.filter.rtStreamStart;
 156     } else if (This->renderer.filter.pClock) {
 157         IReferenceClock_GetTime(This->renderer.filter.pClock, &cur);
 158         cur -= This->renderer.filter.rtStreamStart;
 159     } else
 160         write_at = -1;
 161
 162     if (writepos == min_writepos)
 163         max_lag = 0;
 164
 165     *skip = 0;
 166     if (write_at < 0) {
 167         *ret_writepos = writepos;
 168         goto end;
 169     }
 170
 171     if (writepos >= playpos)
 172         writepos_t = cur + time_from_pos(This, writepos - playpos);
 173     else
 174         writepos_t = cur + time_from_pos(This, This->buf_size + writepos - playpos);
 175
 176     /* write_at: Starting time of sample */
 177     /* cur: current time of play position */
 178     /* writepos_t: current time of our pointer play position */
 179     delta_t = write_at - writepos_t;
 180     if (delta_t >= -max_lag && delta_t <= max_lag) {
 181         TRACE("Continuing from old position\n");
 182         *ret_writepos = writepos;
 183     } else if (delta_t < 0) {
 184         REFERENCE_TIME past, min_writepos_t;
 185         WARN("Delta too big %i/%i, overwriting old data or even skipping\n", (int)delta_t / 10000, (int)max_lag / 10000);
 186         if (min_writepos >= playpos)
 187             min_writepos_t = cur + time_from_pos(This, min_writepos - playpos);
 188         else
 189             min_writepos_t = cur + time_from_pos(This, This->buf_size - playpos + min_writepos);
 190         past = min_writepos_t - write_at;
 191         if (past >= 0) {
 192             DWORD skipbytes = pos_from_time(This, past);
 193             WARN("Skipping %u bytes\n", skipbytes);
 194             *skip = skipbytes;
 195             *ret_writepos = min_writepos;
 196         } else {
 197             DWORD aheadbytes = pos_from_time(This, -past);
 198             WARN("Advancing %u bytes\n", aheadbytes);
 199             *ret_writepos = (min_writepos + aheadbytes) % This->buf_size;
 200         }
 201     } else /* delta_t > 0 */ {
 202         DWORD aheadbytes;
 203         WARN("Delta too big %i/%i, too far ahead\n", (int)delta_t / 10000, (int)max_lag / 10000);
 204         aheadbytes = pos_from_time(This, delta_t);
 205         WARN("Advancing %u bytes\n", aheadbytes);
 206         if (delta_t >= DSoundRenderer_Max_Fill)
 207             return S_FALSE;
 208         *ret_writepos = (min_writepos + aheadbytes) % This->buf_size;
 209     }
 210 end:
 211     if (playpos > *ret_writepos)
 212         *pfree = playpos - *ret_writepos;
 213     else if (playpos == *ret_writepos)
 214         *pfree = This->buf_size - wfx->nBlockAlign;
 215     else
 216         *pfree = This->buf_size + playpos - *ret_writepos;
 217     if (time_from_pos(This, This->buf_size - *pfree) >= DSoundRenderer_Max_Fill) {
 218         TRACE("Blocked: too full %i / %i\n", (int)(time_from_pos(This, This->buf_size - *pfree)/10000), (int)(DSoundRenderer_Max_Fill / 10000));
 219         return S_FALSE;
 220     }
 221     return S_OK;
 222 }
 223
 224 static HRESULT DSoundRender_HandleEndOfStream(DSoundRenderImpl *This)
 225 {
 226     HRESULT hr;
 227     IMediaEventSink *pEventSink;
 228
 229     while (1)
 230     {
 231         DWORD pos1, pos2;
 232         DSoundRender_UpdatePositions(This, &pos1, &pos2);
 233         if (pos1 == pos2)
 234             break;
 235
 236         This->in_loop = 1;
 237         LeaveCriticalSection(&This->renderer.filter.csFilter);
 238         LeaveCriticalSection(&This->renderer.csRenderLock);
 239         WaitForSingleObject(This->blocked, 10);
 240         EnterCriticalSection(&This->renderer.filter.csFilter);
 241         EnterCriticalSection(&This->renderer.csRenderLock);
 242         This->in_loop = 0;
 243         if (This->renderer.pInputPin->flushing ||
 244             This->renderer.filter.state != State_Running) {
 245             SetEvent(This->renderer.evComplete);
 246             return S_FALSE;
 247         }
 248     }
 249
 250     if (!This->renderer.filter.filterInfo.pGraph)
 251         return S_OK;
 252
 253     hr = IFilterGraph_QueryInterface(This->renderer.filter.filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
 254     if (SUCCEEDED(hr))
 255     {
 256         hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, (LONG_PTR)This);
 257         IMediaEventSink_Release(pEventSink);
 258     }
 259     return hr;
 260 }
 261
 262 static HRESULT DSoundRender_SendSampleData(DSoundRenderImpl* This, REFERENCE_TIME tStart, REFERENCE_TIME tStop, const BYTE *data, DWORD size)
 263 {
 264     HRESULT hr;
 265
 266     while (size && This->renderer.filter.state != State_Stopped) {
 267         DWORD writepos, skip = 0, free, size1, size2, ret;
 268         BYTE *buf1, *buf2;
 269
 270         if (This->renderer.filter.state == State_Running)
 271             hr = DSoundRender_GetWritePos(This, &writepos, tStart, &free, &skip);
 272         else
 273             hr = S_FALSE;
 274
 275         if (hr != S_OK) {
 276             This->in_loop = 1;
 277             LeaveCriticalSection(&This->renderer.csRenderLock);
 278             ret = WaitForSingleObject(This->blocked, 10);
 279             EnterCriticalSection(&This->renderer.csRenderLock);
 280             This->in_loop = 0;
 281             if (This->renderer.pInputPin->flushing ||
 282                 This->renderer.filter.state == State_Stopped) {
 283                 SetEvent(This->renderer.evComplete);
 284                 return This->renderer.filter.state == State_Paused ? S_OK : VFW_E_WRONG_STATE;
 285             }
 286             if (ret != WAIT_TIMEOUT)
 287                 ERR("%x\n", ret);
 288             continue;
 289         }
 290         tStart = -1;
 291
 292         if (skip)
 293             FIXME("Sample dropped %u of %u bytes\n", skip, size);
 294         if (skip >= size)
 295             return S_OK;
 296         data += skip;
 297         size -= skip;
 298
 299         hr = IDirectSoundBuffer_Lock(This->dsbuffer, writepos, min(free, size), (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
 300         if (hr != DS_OK) {
 301             ERR("Unable to lock sound buffer! (%x)\n", hr);
 302             break;
 303         }
 304         memcpy(buf1, data, size1);
 305         if (size2)
 306             memcpy(buf2, data+size1, size2);
 307         IDirectSoundBuffer_Unlock(This->dsbuffer, buf1, size1, buf2, size2);
 308         This->writepos = (writepos + size1 + size2) % This->buf_size;
 309         TRACE("Wrote %u bytes at %u, next at %u - (%u/%u)\n", size1+size2, writepos, This->writepos, free, size);
 310         data += size1 + size2;
 311         size -= size1 + size2;
 312     }
 313     return S_OK;
 314 }
 315
 316 static HRESULT WINAPI DSoundRender_ShouldDrawSampleNow(BaseRenderer *This, IMediaSample *pMediaSample, REFERENCE_TIME *pStartTime, REFERENCE_TIME *pEndTime)
 317 {
 318     /* We time ourselves do not use the base renderers timing */
 319     return S_OK;
 320 }
 321
 322
 323 HRESULT WINAPI DSoundRender_PrepareReceive(BaseRenderer *iface, IMediaSample *pSample)
 324 {
 325     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 326     HRESULT hr;
 327     AM_MEDIA_TYPE *amt;
 328
 329     if (IMediaSample_GetMediaType(pSample, &amt) == S_OK)
 330     {
 331         AM_MEDIA_TYPE *orig = &This->renderer.pInputPin->pin.mtCurrent;
 332         WAVEFORMATEX *origfmt = (WAVEFORMATEX *)orig->pbFormat;
 333         WAVEFORMATEX *newfmt = (WAVEFORMATEX *)amt->pbFormat;
 334
 335         if (origfmt->wFormatTag == newfmt->wFormatTag &&
 336             origfmt->nChannels == newfmt->nChannels &&
 337             origfmt->nBlockAlign == newfmt->nBlockAlign &&
 338             origfmt->wBitsPerSample == newfmt->wBitsPerSample &&
 339             origfmt->cbSize ==  newfmt->cbSize)
 340         {
 341             if (origfmt->nSamplesPerSec != newfmt->nSamplesPerSec)
 342             {
 343                 hr = IDirectSoundBuffer_SetFrequency(This->dsbuffer,
 344                                                      newfmt->nSamplesPerSec);
 345                 if (FAILED(hr))
 346                     return VFW_E_TYPE_NOT_ACCEPTED;
 347                 FreeMediaType(orig);
 348                 CopyMediaType(orig, amt);
 349                 IMediaSample_SetMediaType(pSample, NULL);
 350             }
 351         }
 352         else
 353             return VFW_E_TYPE_NOT_ACCEPTED;
 354     }
 355     return S_OK;
 356 }
 357
 358 static HRESULT WINAPI DSoundRender_DoRenderSample(BaseRenderer *iface, IMediaSample * pSample)
 359 {
 360     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 361     LPBYTE pbSrcStream = NULL;
 362     LONG cbSrcStream = 0;
 363     REFERENCE_TIME tStart, tStop;
 364     HRESULT hr;
 365
 366     TRACE("%p %p\n", iface, pSample);
 367
 368     /* Slightly incorrect, Pause completes when a frame is received so we should signal
 369      * pause completion here, but for sound playing a single frame doesn't make sense
 370      */
 371
 372     hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
 373     if (FAILED(hr))
 374     {
 375         ERR("Cannot get pointer to sample data (%x)\n", hr);
 376         return hr;
 377     }
 378
 379     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
 380     if (FAILED(hr)) {
 381         ERR("Cannot get sample time (%x)\n", hr);
 382         tStart = tStop = -1;
 383     }
 384
 385     IMediaSample_IsDiscontinuity(pSample);
 386
 387     if (IMediaSample_IsPreroll(pSample) == S_OK)
 388     {
 389         TRACE("Preroll!\n");
 390         return S_OK;
 391     }
 392
 393     cbSrcStream = IMediaSample_GetActualDataLength(pSample);
 394     TRACE("Sample data ptr = %p, size = %d\n", pbSrcStream, cbSrcStream);
 395
 396     hr = DSoundRender_SendSampleData(This, tStart, tStop, pbSrcStream, cbSrcStream);
 397     if (This->renderer.filter.state == State_Running && This->renderer.filter.pClock && tStart >= 0) {
 398         REFERENCE_TIME jitter, now = 0;
 399         Quality q;
 400         IReferenceClock_GetTime(This->renderer.filter.pClock, &now);
 401         jitter = now - This->renderer.filter.rtStreamStart - tStart;
 402         if (jitter <= -DSoundRenderer_Max_Fill)
 403             jitter += DSoundRenderer_Max_Fill;
 404         else if (jitter < 0)
 405             jitter = 0;
 406         q.Type = (jitter > 0 ? Famine : Flood);
 407         q.Proportion = 1.;
 408         q.Late = jitter;
 409         q.TimeStamp = tStart;
 410         IQualityControl_Notify((IQualityControl *)This->renderer.qcimpl, (IBaseFilter*)This, q);
 411     }
 412     return hr;
 413 }
 414
 415 static HRESULT WINAPI DSoundRender_CheckMediaType(BaseRenderer *iface, const AM_MEDIA_TYPE * pmt)
 416 {
 417     WAVEFORMATEX* format;
 418
 419     if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Audio))
 420         return S_FALSE;
 421
 422     format =  (WAVEFORMATEX*)pmt->pbFormat;
 423     TRACE("Format = %p\n", format);
 424     TRACE("wFormatTag = %x %x\n", format->wFormatTag, WAVE_FORMAT_PCM);
 425     TRACE("nChannels = %d\n", format->nChannels);
 426     TRACE("nSamplesPerSec = %d\n", format->nAvgBytesPerSec);
 427     TRACE("nAvgBytesPerSec = %d\n", format->nAvgBytesPerSec);
 428     TRACE("nBlockAlign = %d\n", format->nBlockAlign);
 429     TRACE("wBitsPerSample = %d\n", format->wBitsPerSample);
 430
 431     if (!IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_PCM))
 432         return S_FALSE;
 433
 434     return S_OK;
 435 }
 436
 437 static VOID WINAPI DSoundRender_OnStopStreaming(BaseRenderer * iface)
 438 {
 439     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 440
 441     TRACE("(%p/%p)->()\n", This, iface);
 442
 443     IDirectSoundBuffer_Stop(This->dsbuffer);
 444     This->writepos = This->buf_size;
 445     SetEvent(This->blocked);
 446 }
 447
 448 static VOID WINAPI DSoundRender_OnStartStreaming(BaseRenderer * iface)
 449 {
 450     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 451
 452     TRACE("(%p)\n", This);
 453
 454     if (This->renderer.pInputPin->pin.pConnectedTo)
 455     {
 456         if (This->renderer.filter.state == State_Paused)
 457         {
 458             /* Unblock our thread, state changing from paused to running doesn't need a reset for state change */
 459             SetEvent(This->blocked);
 460         }
 461         else if (This->renderer.filter.state == State_Stopped)
 462         {
 463             ResetEvent(This->renderer.evComplete);
 464             This->renderer.pInputPin->end_of_stream = 0;
 465         }
 466         IDirectSoundBuffer_Play(This->dsbuffer, 0, 0, DSBPLAY_LOOPING);
 467         ResetEvent(This->blocked);
 468     }
 469 }
 470
 471 static HRESULT WINAPI DSoundRender_CompleteConnect(BaseRenderer * iface, IPin * pReceivePin)
 472 {
 473     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 474     const AM_MEDIA_TYPE * pmt = &This->renderer.pInputPin->pin.mtCurrent;
 475     HRESULT hr = S_OK;
 476     WAVEFORMATEX *format;
 477     DSBUFFERDESC buf_desc;
 478
 479     TRACE("(%p)->(%p)\n", This, pReceivePin);
 480     dump_AM_MEDIA_TYPE(pmt);
 481
 482     TRACE("MajorType %s\n", debugstr_guid(&pmt->majortype));
 483     TRACE("SubType %s\n", debugstr_guid(&pmt->subtype));
 484     TRACE("Format %s\n", debugstr_guid(&pmt->formattype));
 485     TRACE("Size %d\n", pmt->cbFormat);
 486
 487     format = (WAVEFORMATEX*)pmt->pbFormat;
 488
 489     This->buf_size = format->nAvgBytesPerSec;
 490
 491     memset(&buf_desc,0,sizeof(DSBUFFERDESC));
 492     buf_desc.dwSize = sizeof(DSBUFFERDESC);
 493     buf_desc.dwFlags = DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN |
 494                        DSBCAPS_CTRLFREQUENCY | DSBCAPS_GLOBALFOCUS |
 495                        DSBCAPS_GETCURRENTPOSITION2;
 496     buf_desc.dwBufferBytes = This->buf_size;
 497     buf_desc.lpwfxFormat = format;
 498     hr = IDirectSound_CreateSoundBuffer(This->dsound, &buf_desc, &This->dsbuffer, NULL);
 499     This->writepos = This->buf_size;
 500     if (FAILED(hr))
 501         ERR("Can't create sound buffer (%x)\n", hr);
 502
 503     if (SUCCEEDED(hr))
 504     {
 505         hr = IDirectSoundBuffer_SetVolume(This->dsbuffer, This->volume);
 506         if (FAILED(hr))
 507             ERR("Can't set volume to %d (%x)\n", This->volume, hr);
 508
 509         hr = IDirectSoundBuffer_SetPan(This->dsbuffer, This->pan);
 510         if (FAILED(hr))
 511             ERR("Can't set pan to %d (%x)\n", This->pan, hr);
 512         hr = S_OK;
 513     }
 514
 515     if (FAILED(hr) && hr != VFW_E_ALREADY_CONNECTED)
 516     {
 517         if (This->dsbuffer)
 518             IDirectSoundBuffer_Release(This->dsbuffer);
 519         This->dsbuffer = NULL;
 520     }
 521
 522     return hr;
 523 }
 524
 525 static HRESULT WINAPI DSoundRender_BreakConnect(BaseRenderer* iface)
 526 {
 527     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 528
 529     TRACE("(%p)->()\n", iface);
 530
 531     if (This->threadid) {
 532         PostThreadMessageW(This->threadid, WM_APP, 0, 0);
 533         WaitForSingleObject(This->advisethread, INFINITE);
 534         CloseHandle(This->advisethread);
 535     }
 536     if (This->dsbuffer)
 537         IDirectSoundBuffer_Release(This->dsbuffer);
 538     This->dsbuffer = NULL;
 539
 540     return S_OK;
 541 }
 542
 543 static HRESULT WINAPI DSoundRender_EndOfStream(BaseRenderer* iface)
 544 {
 545     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 546     HRESULT hr;
 547
 548     TRACE("(%p)->()\n",iface);
 549
 550     hr = BaseRendererImpl_EndOfStream(iface);
 551     if (hr != S_OK)
 552     {
 553         ERR("%08x\n", hr);
 554         return hr;
 555     }
 556
 557     hr = DSoundRender_HandleEndOfStream(This);
 558
 559     return hr;
 560 }
 561
 562 static HRESULT WINAPI DSoundRender_BeginFlush(BaseRenderer* iface)
 563 {
 564     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 565
 566     TRACE("\n");
 567     BaseRendererImpl_BeginFlush(iface);
 568     SetEvent(This->blocked);
 569
 570     return S_OK;
 571 }
 572
 573 static HRESULT WINAPI DSoundRender_EndFlush(BaseRenderer* iface)
 574 {
 575     DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
 576
 577     TRACE("\n");
 578
 579     BaseRendererImpl_EndFlush(iface);
 580     if (This->in_loop) {
 581         ResetEvent(This->renderer.evComplete);
 582         LeaveCriticalSection(This->renderer.pInputPin->pin.pCritSec);
 583         LeaveCriticalSection(&This->renderer.filter.csFilter);
 584         LeaveCriticalSection(&This->renderer.csRenderLock);
 585         WaitForSingleObject(This->renderer.evComplete, -1);
 586         EnterCriticalSection(This->renderer.pInputPin->pin.pCritSec);
 587         EnterCriticalSection(&This->renderer.filter.csFilter);
 588         EnterCriticalSection(&This->renderer.csRenderLock);
 589     }
 590     if (This->renderer.filter.state != State_Stopped)
 591         ResetEvent(This->blocked);
 592
 593     if (This->dsbuffer)
 594     {
 595         LPBYTE buffer;
 596         DWORD size;
 597
 598         /* Force a reset */
 599         IDirectSoundBuffer_Lock(This->dsbuffer, 0, 0, (LPVOID *)&buffer, &size, NULL, NULL, DSBLOCK_ENTIREBUFFER);
 600         memset(buffer, 0, size);
 601         IDirectSoundBuffer_Unlock(This->dsbuffer, buffer, size, NULL, 0);
 602         This->writepos = This->buf_size;
 603     }
 604
 605     return S_OK;
 606 }
 607
 608 static const BaseRendererFuncTable BaseFuncTable = {
 609     DSoundRender_CheckMediaType,
 610     DSoundRender_DoRenderSample,
 611     /**/
 612     NULL,
 613     NULL,
 614     NULL,
 615     DSoundRender_OnStartStreaming,
 616     DSoundRender_OnStopStreaming,
 617     NULL,
 618     NULL,
 619     NULL,
 620     DSoundRender_ShouldDrawSampleNow,
 621     DSoundRender_PrepareReceive,
 622     /**/
 623     DSoundRender_CompleteConnect,
 624     DSoundRender_BreakConnect,
 625     DSoundRender_EndOfStream,
 626     DSoundRender_BeginFlush,
 627     DSoundRender_EndFlush,
 628 };
 629
 630 HRESULT DSoundRender_create(IUnknown * pUnkOuter, LPVOID * ppv)
 631 {
 632     HRESULT hr;
 633     DSoundRenderImpl * pDSoundRender;
 634
 635     TRACE("(%p, %p)\n", pUnkOuter, ppv);
 636
 637     *ppv = NULL;
 638
 639     if (pUnkOuter)
 640         return CLASS_E_NOAGGREGATION;
 641
 642     pDSoundRender = CoTaskMemAlloc(sizeof(DSoundRenderImpl));
 643     if (!pDSoundRender)
 644         return E_OUTOFMEMORY;
 645     ZeroMemory(pDSoundRender, sizeof(DSoundRenderImpl));
 646
 647     hr = BaseRenderer_Init(&pDSoundRender->renderer, &DSoundRender_Vtbl, (IUnknown*)pDSoundRender, &CLSID_DSoundRender, (DWORD_PTR)(__FILE__ ": DSoundRenderImpl.csFilter"), &BaseFuncTable);
 648
 649     pDSoundRender->IBasicAudio_vtbl = &IBasicAudio_Vtbl;
 650     pDSoundRender->IReferenceClock_vtbl = &IReferenceClock_Vtbl;
 651     pDSoundRender->IAMDirectSound_vtbl = &IAMDirectSound_Vtbl;
 652     pDSoundRender->IAMFilterMiscFlags_vtbl = &IAMFilterMiscFlags_Vtbl;
 653
 654     if (SUCCEEDED(hr))
 655     {
 656         hr = DirectSoundCreate8(NULL, &pDSoundRender->dsound, NULL);
 657         if (FAILED(hr))
 658             ERR("Cannot create Direct Sound object (%x)\n", hr);
 659         else
 660             hr = IDirectSound_SetCooperativeLevel(pDSoundRender->dsound, GetDesktopWindow(), DSSCL_PRIORITY);
 661         if (SUCCEEDED(hr)) {
 662             IDirectSoundBuffer *buf;
 663             DSBUFFERDESC buf_desc;
 664             memset(&buf_desc,0,sizeof(DSBUFFERDESC));
 665             buf_desc.dwSize = sizeof(DSBUFFERDESC);
 666             buf_desc.dwFlags = DSBCAPS_PRIMARYBUFFER;
 667             hr = IDirectSound_CreateSoundBuffer(pDSoundRender->dsound, &buf_desc, &buf, NULL);
 668             if (SUCCEEDED(hr)) {
 669                 IDirectSoundBuffer_Play(buf, 0, 0, DSBPLAY_LOOPING);
 670                 IUnknown_Release(buf);
 671             }
 672             hr = S_OK;
 673         }
 674     }
 675
 676     if (SUCCEEDED(hr))
 677     {
 678         pDSoundRender->blocked = CreateEventW(NULL, TRUE, TRUE, NULL);
 679
 680         if (!pDSoundRender->blocked || FAILED(hr))
 681         {
 682             IUnknown_Release((IUnknown *)pDSoundRender);
 683             return HRESULT_FROM_WIN32(GetLastError());
 684         }
 685
 686         *ppv = pDSoundRender;
 687     }
 688     else
 689     {
 690         BaseRendererImpl_Release(&pDSoundRender->renderer.filter.IBaseFilter_iface);
 691         CoTaskMemFree(pDSoundRender);
 692     }
 693
 694     return hr;
 695 }
 696
 697 static HRESULT WINAPI DSoundRender_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 698 {
 699     DSoundRenderImpl *This = impl_from_IBaseFilter(iface);
 700     TRACE("(%p, %p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 701
 702     *ppv = NULL;
 703
 704     if (IsEqualIID(riid, &IID_IBasicAudio))
 705         *ppv = &This->IBasicAudio_vtbl;
 706     else if (IsEqualIID(riid, &IID_IReferenceClock))
 707         *ppv = &This->IReferenceClock_vtbl;
 708     else if (IsEqualIID(riid, &IID_IAMDirectSound))
 709         *ppv = &This->IAMDirectSound_vtbl;
 710     else if (IsEqualIID(riid, &IID_IAMFilterMiscFlags))
 711         *ppv = &This->IAMFilterMiscFlags_vtbl;
 712     else
 713     {
 714         HRESULT hr;
 715         hr = BaseRendererImpl_QueryInterface(iface, riid, ppv);
 716         if (SUCCEEDED(hr))
 717             return hr;
 718     }
 719
 720     if (*ppv)
 721     {
 722         IUnknown_AddRef((IUnknown *)(*ppv));
 723         return S_OK;
 724     }
 725
 726     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow))
 727         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 728
 729     return E_NOINTERFACE;
 730 }
 731
 732 static ULONG WINAPI DSoundRender_Release(IBaseFilter * iface)
 733 {
 734     DSoundRenderImpl *This = impl_from_IBaseFilter(iface);
 735     ULONG refCount = BaseRendererImpl_Release(iface);
 736
 737     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 738
 739     if (!refCount)
 740     {
 741         if (This->threadid) {
 742             PostThreadMessageW(This->threadid, WM_APP, 0, 0);
 743             WaitForSingleObject(This->advisethread, INFINITE);
 744             CloseHandle(This->advisethread);
 745         }
 746
 747         if (This->dsbuffer)
 748             IDirectSoundBuffer_Release(This->dsbuffer);
 749         This->dsbuffer = NULL;
 750         if (This->dsound)
 751             IDirectSound_Release(This->dsound);
 752         This->dsound = NULL;
 753
 754         This->IBasicAudio_vtbl = NULL;
 755
 756         CloseHandle(This->blocked);
 757
 758         TRACE("Destroying Audio Renderer\n");
 759         CoTaskMemFree(This);
 760
 761         return 0;
 762     }
 763     else
 764         return refCount;
 765 }
 766
 767 static const IBaseFilterVtbl DSoundRender_Vtbl =
 768 {
 769     DSoundRender_QueryInterface,
 770     BaseFilterImpl_AddRef,
 771     DSoundRender_Release,
 772     BaseFilterImpl_GetClassID,
 773     BaseRendererImpl_Stop,
 774     BaseRendererImpl_Pause,
 775     BaseRendererImpl_Run,
 776     BaseRendererImpl_GetState,
 777     BaseRendererImpl_SetSyncSource,
 778     BaseFilterImpl_GetSyncSource,
 779     BaseFilterImpl_EnumPins,
 780     BaseRendererImpl_FindPin,
 781     BaseFilterImpl_QueryFilterInfo,
 782     BaseFilterImpl_JoinFilterGraph,
 783     BaseFilterImpl_QueryVendorInfo
 784 };
 785
 786 /*** IUnknown methods ***/
 787 static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface,
 788                                                 REFIID riid,
 789                                                 LPVOID*ppvObj) {
 790     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 791
 792     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 793
 794     return DSoundRender_QueryInterface(&This->renderer.filter.IBaseFilter_iface, riid, ppvObj);
 795 }
 796
 797 static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) {
 798     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 799
 800     TRACE("(%p/%p)->()\n", This, iface);
 801
 802     return BaseFilterImpl_AddRef(&This->renderer.filter.IBaseFilter_iface);
 803 }
 804
 805 static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) {
 806     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 807
 808     TRACE("(%p/%p)->()\n", This, iface);
 809
 810     return DSoundRender_Release(&This->renderer.filter.IBaseFilter_iface);
 811 }
 812
 813 /*** IDispatch methods ***/
 814 static HRESULT WINAPI Basicaudio_GetTypeInfoCount(IBasicAudio *iface,
 815                                                   UINT*pctinfo) {
 816     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 817
 818     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
 819
 820     return S_OK;
 821 }
 822
 823 static HRESULT WINAPI Basicaudio_GetTypeInfo(IBasicAudio *iface,
 824                                              UINT iTInfo,
 825                                              LCID lcid,
 826                                              ITypeInfo**ppTInfo) {
 827     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 828
 829     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
 830
 831     return S_OK;
 832 }
 833
 834 static HRESULT WINAPI Basicaudio_GetIDsOfNames(IBasicAudio *iface,
 835                                                REFIID riid,
 836                                                LPOLESTR*rgszNames,
 837                                                UINT cNames,
 838                                                LCID lcid,
 839                                                DISPID*rgDispId) {
 840     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 841
 842     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
 843
 844     return S_OK;
 845 }
 846
 847 static HRESULT WINAPI Basicaudio_Invoke(IBasicAudio *iface,
 848                                         DISPID dispIdMember,
 849                                         REFIID riid,
 850                                         LCID lcid,
 851                                         WORD wFlags,
 852                                         DISPPARAMS*pDispParams,
 853                                         VARIANT*pVarResult,
 854                                         EXCEPINFO*pExepInfo,
 855                                         UINT*puArgErr) {
 856     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 857
 858     TRACE("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
 859
 860     return S_OK;
 861 }
 862
 863 /*** IBasicAudio methods ***/
 864 static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface,
 865                                             LONG lVolume) {
 866     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 867
 868     TRACE("(%p/%p)->(%d)\n", This, iface, lVolume);
 869
 870     if (lVolume > DSBVOLUME_MAX || lVolume < DSBVOLUME_MIN)
 871         return E_INVALIDARG;
 872
 873     if (This->dsbuffer) {
 874         if (FAILED(IDirectSoundBuffer_SetVolume(This->dsbuffer, lVolume)))
 875             return E_FAIL;
 876     }
 877
 878     This->volume = lVolume;
 879     return S_OK;
 880 }
 881
 882 static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface,
 883                                             LONG *plVolume) {
 884     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 885
 886     TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
 887
 888     if (!plVolume)
 889         return E_POINTER;
 890
 891     *plVolume = This->volume;
 892     return S_OK;
 893 }
 894
 895 static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface,
 896                                              LONG lBalance) {
 897     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 898
 899     TRACE("(%p/%p)->(%d)\n", This, iface, lBalance);
 900
 901     if (lBalance < DSBPAN_LEFT || lBalance > DSBPAN_RIGHT)
 902         return E_INVALIDARG;
 903
 904     if (This->dsbuffer) {
 905         if (FAILED(IDirectSoundBuffer_SetPan(This->dsbuffer, lBalance)))
 906             return E_FAIL;
 907     }
 908
 909     This->pan = lBalance;
 910     return S_OK;
 911 }
 912
 913 static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface,
 914                                              LONG *plBalance) {
 915     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 916
 917     TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
 918
 919     if (!plBalance)
 920         return E_POINTER;
 921
 922     *plBalance = This->pan;
 923     return S_OK;
 924 }
 925
 926 static const IBasicAudioVtbl IBasicAudio_Vtbl =
 927 {
 928     Basicaudio_QueryInterface,
 929     Basicaudio_AddRef,
 930     Basicaudio_Release,
 931     Basicaudio_GetTypeInfoCount,
 932     Basicaudio_GetTypeInfo,
 933     Basicaudio_GetIDsOfNames,
 934     Basicaudio_Invoke,
 935     Basicaudio_put_Volume,
 936     Basicaudio_get_Volume,
 937     Basicaudio_put_Balance,
 938     Basicaudio_get_Balance
 939 };
 940
 941 struct dsoundrender_timer {
 942     struct dsoundrender_timer *next;
 943     REFERENCE_TIME start;
 944     REFERENCE_TIME periodicity;
 945     HANDLE handle;
 946     DWORD cookie;
 947 };
 948 static LONG cookie_counter = 1;
 949
 950 static DWORD WINAPI DSoundAdviseThread(LPVOID lpParam) {
 951     DSoundRenderImpl *This = lpParam;
 952     struct dsoundrender_timer head = { };
 953     MSG msg;
 954
 955     TRACE("(%p): Main Loop\n", This);
 956
 957     PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 958     SetEvent(This->thread_wait);
 959
 960     while (1)
 961     {
 962         HRESULT hr;
 963         REFERENCE_TIME curtime = 0;
 964         BOOL ret;
 965         struct dsoundrender_timer *prev = &head, *cur;
 966
 967         hr = IReferenceClock_GetTime((IReferenceClock*) &This->IReferenceClock_vtbl, &curtime);
 968         if (FAILED(hr)) {
 969             FIXME("Could not get time: %08x\n", hr);
 970             continue;
 971         }
 972         TRACE("Time: %s\n", wine_dbgstr_longlong(curtime));
 973         while (prev->next) {
 974             cur = prev->next;
 975             if (cur->start > curtime) {
 976                 TRACE("Skipping %p\n", cur);
 977                 prev = cur;
 978             } else if (cur->periodicity) {
 979                 while (cur->start <= curtime) {
 980                     cur->start += cur->periodicity;
 981                     ReleaseSemaphore(cur->handle, 1, NULL);
 982                 }
 983                 prev = cur;
 984             } else {
 985                 struct dsoundrender_timer *next = cur->next;
 986                 TRACE("Firing %p %s < %s\n", cur, wine_dbgstr_longlong(cur->start), wine_dbgstr_longlong(curtime));
 987                 SetEvent(cur->handle);
 988                 HeapFree(GetProcessHeap(), 0, cur);
 989                 prev->next = next;
 990             }
 991         }
 992         if (!head.next)
 993             ret = GetMessageW(&msg, INVALID_HANDLE_VALUE, WM_APP, WM_APP + 4);
 994         else
 995             ret = PeekMessageW(&msg, INVALID_HANDLE_VALUE, WM_APP, WM_APP + 4, PM_REMOVE);
 996         while (ret) {
 997             switch (LOWORD(msg.message) - WM_APP) {
 998                 case 0: TRACE("Exiting\n"); return 0;
 999                 case 1:
1000                 case 2: {
1001                     struct dsoundrender_timer *t = (struct dsoundrender_timer *)msg.wParam;
1002                     if (LOWORD(msg.message) - WM_APP == 1)
1003                         TRACE("Adding one-shot timer %p\n", t);
1004                     else
1005                         TRACE("Adding periodic timer %p\n", t);
1006                     t->next = head.next;
1007                     head.next = t;
1008                     break;
1009                 }
1010                 case 3:
1011                     prev = &head;
1012                     while (prev->next) {
1013                         cur = prev->next;
1014                         if (cur->cookie == msg.wParam) {
1015                             struct dsoundrender_timer *next = cur->next;
1016                             HeapFree(GetProcessHeap(), 0, cur);
1017                             prev->next = next;
1018                             break;
1019                         }
1020                         prev = cur;
1021                     }
1022                     break;
1023             }
1024             ret = PeekMessageW(&msg, INVALID_HANDLE_VALUE, WM_APP, WM_APP + 4, PM_REMOVE);
1025         }
1026         MsgWaitForMultipleObjects(0, NULL, 5, QS_POSTMESSAGE, 0);
1027     }
1028     return 0;
1029 }
1030
1031 /*** IUnknown methods ***/
1032 static HRESULT WINAPI ReferenceClock_QueryInterface(IReferenceClock *iface,
1033                                                 REFIID riid,
1034                                                 LPVOID*ppvObj)
1035 {
1036     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1037
1038     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1039
1040     return DSoundRender_QueryInterface(&This->renderer.filter.IBaseFilter_iface, riid, ppvObj);
1041 }
1042
1043 static ULONG WINAPI ReferenceClock_AddRef(IReferenceClock *iface)
1044 {
1045     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1046
1047     TRACE("(%p/%p)->()\n", This, iface);
1048
1049     return BaseFilterImpl_AddRef(&This->renderer.filter.IBaseFilter_iface);
1050 }
1051
1052 static ULONG WINAPI ReferenceClock_Release(IReferenceClock *iface)
1053 {
1054     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1055
1056     TRACE("(%p/%p)->()\n", This, iface);
1057
1058     return DSoundRender_Release(&This->renderer.filter.IBaseFilter_iface);
1059 }
1060
1061 /*** IReferenceClock methods ***/
1062 static HRESULT WINAPI ReferenceClock_GetTime(IReferenceClock *iface,
1063                                              REFERENCE_TIME *pTime)
1064 {
1065     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1066     HRESULT hr = E_FAIL;
1067
1068     TRACE("(%p/%p)->(%p)\n", This, iface, pTime);
1069     if (!pTime)
1070         return E_POINTER;
1071
1072     if (This->dsbuffer) {
1073         DWORD writepos1, writepos2;
1074         EnterCriticalSection(&This->renderer.filter.csFilter);
1075         DSoundRender_UpdatePositions(This, &writepos1, &writepos2);
1076         *pTime = This->play_time + time_from_pos(This, This->last_playpos);
1077         LeaveCriticalSection(&This->renderer.filter.csFilter);
1078         hr = S_OK;
1079     }
1080     if (FAILED(hr))
1081         WARN("Could not get reference time (%x)!\n", hr);
1082
1083     return hr;
1084 }
1085
1086 static HRESULT WINAPI ReferenceClock_AdviseTime(IReferenceClock *iface,
1087                                                 REFERENCE_TIME rtBaseTime,
1088                                                 REFERENCE_TIME rtStreamTime,
1089                                                 HEVENT hEvent,
1090                                                 DWORD_PTR *pdwAdviseCookie)
1091 {
1092     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1093     REFERENCE_TIME when = rtBaseTime + rtStreamTime;
1094     REFERENCE_TIME future;
1095     TRACE("(%p/%p)->(%s, %s, %p, %p)\n", This, iface, wine_dbgstr_longlong(rtBaseTime), wine_dbgstr_longlong(rtStreamTime), (void*)hEvent, pdwAdviseCookie);
1096
1097     if (when <= 0)
1098         return E_INVALIDARG;
1099
1100     if (!pdwAdviseCookie)
1101         return E_POINTER;
1102
1103     EnterCriticalSection(&This->renderer.filter.csFilter);
1104     future = when - This->play_time;
1105     if (!This->threadid && This->dsbuffer) {
1106         This->thread_wait = CreateEventW(0, 0, 0, 0);
1107         This->advisethread = CreateThread(NULL, 0, DSoundAdviseThread, This, 0, &This->threadid);
1108         WaitForSingleObject(This->thread_wait, INFINITE);
1109         CloseHandle(This->thread_wait);
1110     }
1111     LeaveCriticalSection(&This->renderer.filter.csFilter);
1112     /* If it's in the past or the next millisecond, trigger immediately  */
1113     if (future <= 10000) {
1114         SetEvent((HANDLE)hEvent);
1115         *pdwAdviseCookie = 0;
1116     } else {
1117         struct dsoundrender_timer *t = HeapAlloc(GetProcessHeap(), 0, sizeof(*t));
1118         t->next = NULL;
1119         t->start = when;
1120         t->periodicity = 0;
1121         t->handle = (HANDLE)hEvent;
1122         t->cookie = InterlockedIncrement(&cookie_counter);
1123         PostThreadMessageW(This->threadid, WM_APP+1, (WPARAM)t, 0);
1124         *pdwAdviseCookie = t->cookie;
1125     }
1126
1127     return S_OK;
1128 }
1129
1130 static HRESULT WINAPI ReferenceClock_AdvisePeriodic(IReferenceClock *iface,
1131                                                     REFERENCE_TIME rtStartTime,
1132                                                     REFERENCE_TIME rtPeriodTime,
1133                                                     HSEMAPHORE hSemaphore,
1134                                                     DWORD_PTR *pdwAdviseCookie)
1135 {
1136     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1137     struct dsoundrender_timer *t;
1138
1139     TRACE("(%p/%p)->(%s, %s, %p, %p)\n", This, iface, wine_dbgstr_longlong(rtStartTime), wine_dbgstr_longlong(rtPeriodTime), (void*)hSemaphore, pdwAdviseCookie);
1140
1141     if (rtStartTime <= 0 || rtPeriodTime <= 0)
1142         return E_INVALIDARG;
1143
1144     if (!pdwAdviseCookie)
1145         return E_POINTER;
1146
1147     EnterCriticalSection(&This->renderer.filter.csFilter);
1148     if (!This->threadid && This->dsbuffer) {
1149         This->thread_wait = CreateEventW(0, 0, 0, 0);
1150         This->advisethread = CreateThread(NULL, 0, DSoundAdviseThread, This, 0, &This->threadid);
1151         WaitForSingleObject(This->thread_wait, INFINITE);
1152         CloseHandle(This->thread_wait);
1153     }
1154     LeaveCriticalSection(&This->renderer.filter.csFilter);
1155
1156     t = HeapAlloc(GetProcessHeap(), 0, sizeof(*t));
1157     t->next = NULL;
1158     t->start = rtStartTime;
1159     t->periodicity = rtPeriodTime;
1160     t->handle = (HANDLE)hSemaphore;
1161     t->cookie = InterlockedIncrement(&cookie_counter);
1162     PostThreadMessageW(This->threadid, WM_APP+1, (WPARAM)t, 0);
1163     *pdwAdviseCookie = t->cookie;
1164
1165     return S_OK;
1166 }
1167
1168 static HRESULT WINAPI ReferenceClock_Unadvise(IReferenceClock *iface,
1169                                               DWORD_PTR dwAdviseCookie)
1170 {
1171     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1172
1173     TRACE("(%p/%p)->(%p)\n", This, iface, (void*)dwAdviseCookie);
1174     if (!This->advisethread || !dwAdviseCookie)
1175         return S_FALSE;
1176     PostThreadMessageW(This->threadid, WM_APP+3, dwAdviseCookie, 0);
1177     return S_OK;
1178 }
1179
1180 static const IReferenceClockVtbl IReferenceClock_Vtbl =
1181 {
1182     ReferenceClock_QueryInterface,
1183     ReferenceClock_AddRef,
1184     ReferenceClock_Release,
1185     ReferenceClock_GetTime,
1186     ReferenceClock_AdviseTime,
1187     ReferenceClock_AdvisePeriodic,
1188     ReferenceClock_Unadvise
1189 };
1190
1191 /*** IUnknown methods ***/
1192 static HRESULT WINAPI AMDirectSound_QueryInterface(IAMDirectSound *iface,
1193                                                 REFIID riid,
1194                                                 LPVOID*ppvObj)
1195 {
1196     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1197
1198     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1199
1200     return DSoundRender_QueryInterface(&This->renderer.filter.IBaseFilter_iface, riid, ppvObj);
1201 }
1202
1203 static ULONG WINAPI AMDirectSound_AddRef(IAMDirectSound *iface)
1204 {
1205     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1206
1207     TRACE("(%p/%p)->()\n", This, iface);
1208
1209     return BaseFilterImpl_AddRef(&This->renderer.filter.IBaseFilter_iface);
1210 }
1211
1212 static ULONG WINAPI AMDirectSound_Release(IAMDirectSound *iface)
1213 {
1214     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1215
1216     TRACE("(%p/%p)->()\n", This, iface);
1217
1218     return DSoundRender_Release(&This->renderer.filter.IBaseFilter_iface);
1219 }
1220
1221 /*** IAMDirectSound methods ***/
1222 static HRESULT WINAPI AMDirectSound_GetDirectSoundInterface(IAMDirectSound *iface,  IDirectSound **ds)
1223 {
1224     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1225
1226     FIXME("(%p/%p)->(%p): stub\n", This, iface, ds);
1227
1228     return E_NOTIMPL;
1229 }
1230
1231 static HRESULT WINAPI AMDirectSound_GetPrimaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer **buf)
1232 {
1233     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1234
1235     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
1236
1237     return E_NOTIMPL;
1238 }
1239
1240 static HRESULT WINAPI AMDirectSound_GetSecondaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer **buf)
1241 {
1242     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1243
1244     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
1245
1246     return E_NOTIMPL;
1247 }
1248
1249 static HRESULT WINAPI AMDirectSound_ReleaseDirectSoundInterface(IAMDirectSound *iface, IDirectSound *ds)
1250 {
1251     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1252
1253     FIXME("(%p/%p)->(%p): stub\n", This, iface, ds);
1254
1255     return E_NOTIMPL;
1256 }
1257
1258 static HRESULT WINAPI AMDirectSound_ReleasePrimaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer *buf)
1259 {
1260     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1261
1262     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
1263
1264     return E_NOTIMPL;
1265 }
1266
1267 static HRESULT WINAPI AMDirectSound_ReleaseSecondaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer *buf)
1268 {
1269     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1270
1271     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
1272
1273     return E_NOTIMPL;
1274 }
1275
1276 static HRESULT WINAPI AMDirectSound_SetFocusWindow(IAMDirectSound *iface, HWND hwnd, BOOL bgsilent)
1277 {
1278     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1279
1280     FIXME("(%p/%p)->(%p,%d): stub\n", This, iface, hwnd, bgsilent);
1281
1282     return E_NOTIMPL;
1283 }
1284
1285 static HRESULT WINAPI AMDirectSound_GetFocusWindow(IAMDirectSound *iface, HWND hwnd)
1286 {
1287     ICOM_THIS_MULTI(DSoundRenderImpl, IAMDirectSound_vtbl, iface);
1288
1289     FIXME("(%p/%p)->(%p): stub\n", This, iface, hwnd);
1290
1291     return E_NOTIMPL;
1292 }
1293
1294 static const IAMDirectSoundVtbl IAMDirectSound_Vtbl =
1295 {
1296     AMDirectSound_QueryInterface,
1297     AMDirectSound_AddRef,
1298     AMDirectSound_Release,
1299     AMDirectSound_GetDirectSoundInterface,
1300     AMDirectSound_GetPrimaryBufferInterface,
1301     AMDirectSound_GetSecondaryBufferInterface,
1302     AMDirectSound_ReleaseDirectSoundInterface,
1303     AMDirectSound_ReleasePrimaryBufferInterface,
1304     AMDirectSound_ReleaseSecondaryBufferInterface,
1305     AMDirectSound_SetFocusWindow,
1306     AMDirectSound_GetFocusWindow
1307 };
1308
1309 static DSoundRenderImpl *from_IAMFilterMiscFlags(IAMFilterMiscFlags *iface) {
1310     return (DSoundRenderImpl*)((char*)iface - offsetof(DSoundRenderImpl, IAMFilterMiscFlags_vtbl));
1311 }
1312
1313 static HRESULT WINAPI AMFilterMiscFlags_QueryInterface(IAMFilterMiscFlags *iface, REFIID riid, void **ppv) {
1314     DSoundRenderImpl *This = from_IAMFilterMiscFlags(iface);
1315     return IUnknown_QueryInterface((IUnknown*)This, riid, ppv);
1316 }
1317
1318 static ULONG WINAPI AMFilterMiscFlags_AddRef(IAMFilterMiscFlags *iface) {
1319     DSoundRenderImpl *This = from_IAMFilterMiscFlags(iface);
1320     return IUnknown_AddRef((IUnknown*)This);
1321 }
1322
1323 static ULONG WINAPI AMFilterMiscFlags_Release(IAMFilterMiscFlags *iface) {
1324     DSoundRenderImpl *This = from_IAMFilterMiscFlags(iface);
1325     return IUnknown_Release((IUnknown*)This);
1326 }
1327
1328 static ULONG WINAPI AMFilterMiscFlags_GetMiscFlags(IAMFilterMiscFlags *iface) {
1329     return AM_FILTER_MISC_FLAGS_IS_RENDERER;
1330 }
1331
1332 static const IAMFilterMiscFlagsVtbl IAMFilterMiscFlags_Vtbl = {
1333     AMFilterMiscFlags_QueryInterface,
1334     AMFilterMiscFlags_AddRef,
1335     AMFilterMiscFlags_Release,
1336     AMFilterMiscFlags_GetMiscFlags
1337 };