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 "control_private.h"
  25 #include "pin.h"
  26
  27 #include "uuids.h"
  28 #include "vfwmsgs.h"
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "dshow.h"
  32 #include "evcode.h"
  33 #include "strmif.h"
  34 #include "dsound.h"
  35
  36 #include "wine/unicode.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  40
  41 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  42
  43 static const IBaseFilterVtbl DSoundRender_Vtbl;
  44 static const IPinVtbl DSoundRender_InputPin_Vtbl;
  45 static const IBasicAudioVtbl IBasicAudio_Vtbl;
  46 static const IReferenceClockVtbl IReferenceClock_Vtbl;
  47 static const IMediaSeekingVtbl IMediaSeeking_Vtbl;
  48
  49 typedef struct DSoundRenderImpl
  50 {
  51     const IBaseFilterVtbl * lpVtbl;
  52     const IBasicAudioVtbl *IBasicAudio_vtbl;
  53     const IReferenceClockVtbl *IReferenceClock_vtbl;
  54
  55     LONG refCount;
  56     CRITICAL_SECTION csFilter;
  57     FILTER_STATE state;
  58     REFERENCE_TIME rtStreamStart, rtLastStop;
  59     IReferenceClock * pClock;
  60     FILTER_INFO filterInfo;
  61
  62     InputPin * pInputPin;
  63
  64     IDirectSound8 *dsound;
  65     LPDIRECTSOUNDBUFFER dsbuffer;
  66     DWORD buf_size;
  67     DWORD write_pos;
  68     DWORD write_loops;
  69
  70     DWORD last_play_pos;
  71     DWORD play_loops;
  72
  73     REFERENCE_TIME play_time;
  74     MediaSeekingImpl mediaSeeking;
  75
  76     long volume;
  77     long pan;
  78 } DSoundRenderImpl;
  79
  80 /* Seeking is not needed for a renderer, rely on newsegment for the appropriate changes */
  81 static HRESULT sound_mod_stop(IBaseFilter *iface)
  82 {
  83     TRACE("(%p)\n", iface);
  84     return S_OK;
  85 }
  86
  87 static HRESULT sound_mod_start(IBaseFilter *iface)
  88 {
  89     TRACE("(%p)\n", iface);
  90
  91     return S_OK;
  92 }
  93
  94 static HRESULT sound_mod_rate(IBaseFilter *iface)
  95 {
  96     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
  97
  98     WAVEFORMATEX *format = (WAVEFORMATEX*)This->pInputPin->pin.mtCurrent.pbFormat;
  99     DWORD freq = format->nSamplesPerSec;
 100     double rate = This->mediaSeeking.dRate;
 101
 102     freq = (DWORD)((double)freq * rate);
 103
 104     TRACE("(%p)\n", iface);
 105
 106     if (freq > DSBFREQUENCY_MAX)
 107         return VFW_E_UNSUPPORTED_AUDIO;
 108
 109     if (freq < DSBFREQUENCY_MIN)
 110         return VFW_E_UNSUPPORTED_AUDIO;
 111
 112     return S_OK;
 113 }
 114
 115 static inline HRESULT DSoundRender_GetPos(DSoundRenderImpl *This, DWORD *pPlayPos, REFERENCE_TIME *pRefTime)
 116 {
 117     HRESULT hr;
 118
 119     EnterCriticalSection(&This->csFilter);
 120     {
 121         DWORD state;
 122         DWORD write_pos;
 123
 124         hr = IDirectSoundBuffer_GetStatus(This->dsbuffer, &state);
 125         if (SUCCEEDED(hr) && !(state & DSBSTATUS_PLAYING) && This->state == State_Running)
 126         {
 127             TRACE("Not playing, kickstarting the engine\n");
 128
 129             hr = IDirectSoundBuffer_Play(This->dsbuffer, 0, 0, DSBPLAY_LOOPING);
 130             if (FAILED(hr))
 131                 ERR("Can't play sound buffer (%x)\n", hr);
 132         }
 133
 134         if (SUCCEEDED(hr))
 135             hr = IDirectSoundBuffer_GetCurrentPosition(This->dsbuffer, pPlayPos, &write_pos);
 136         if (hr == S_OK)
 137         {
 138             DWORD play_pos = *pPlayPos;
 139
 140             if (play_pos < This->last_play_pos)
 141                 This->play_loops++;
 142             This->last_play_pos = play_pos;
 143
 144             /* If we really fell behind, start at the next possible position
 145              * Also happens when just starting playback for the first time,
 146              * or when flushing
 147              */
 148             if ((This->play_loops*This->buf_size)+play_pos >=
 149                 (This->write_loops*This->buf_size)+This->write_pos)
 150                 This->write_pos = write_pos;
 151
 152             if (pRefTime)
 153             {
 154                 REFERENCE_TIME play_time;
 155                 play_time = ((REFERENCE_TIME)This->play_loops*10000000) +
 156                             ((REFERENCE_TIME)play_pos*10000000/This->buf_size);
 157
 158                 /* Don't let time run backwards */
 159                 if(play_time-This->play_time > 0)
 160                     This->play_time = play_time;
 161                 else
 162                     hr = S_FALSE;
 163
 164                 *pRefTime = This->play_time;
 165             }
 166         }
 167     }
 168     LeaveCriticalSection(&This->csFilter);
 169
 170     return hr;
 171 }
 172
 173 static HRESULT DSoundRender_SendSampleData(DSoundRenderImpl* This, const BYTE *data, DWORD size)
 174 {
 175     HRESULT hr = S_OK;
 176     LPBYTE lpbuf1 = NULL;
 177     LPBYTE lpbuf2 = NULL;
 178     DWORD dwsize1 = 0;
 179     DWORD dwsize2 = 0;
 180     DWORD size2;
 181     DWORD play_pos,buf_free;
 182
 183     do {
 184
 185         hr = DSoundRender_GetPos(This, &play_pos, NULL);
 186         if (hr != DS_OK)
 187         {
 188             ERR("GetPos returned error: %x\n", hr);
 189             break;
 190         }
 191         if (This->write_pos <= play_pos)
 192              buf_free = play_pos-This->write_pos;
 193         else
 194              buf_free = This->buf_size - This->write_pos + play_pos;
 195
 196         /* Wait for enough of the buffer to empty before filling it */
 197         if(buf_free < This->buf_size/4)
 198         {
 199             Sleep(50);
 200             continue;
 201         }
 202
 203         size2 = min(buf_free, size);
 204         hr = IDirectSoundBuffer_Lock(This->dsbuffer, This->write_pos, size2, (LPVOID *)&lpbuf1, &dwsize1, (LPVOID *)&lpbuf2, &dwsize2, 0);
 205         if (hr != DS_OK) {
 206             ERR("Unable to lock sound buffer! (%x)\n", hr);
 207             break;
 208         }
 209         /* TRACE("write_pos=%d, size=%d, sz1=%d, sz2=%d\n", This->write_pos, size2, dwsize1, dwsize2); */
 210
 211         memcpy(lpbuf1, data, dwsize1);
 212         if (dwsize2)
 213             memcpy(lpbuf2, data + dwsize1, dwsize2);
 214
 215         hr = IDirectSoundBuffer_Unlock(This->dsbuffer, lpbuf1, dwsize1, lpbuf2, dwsize2);
 216         if (hr != DS_OK)
 217             ERR("Unable to unlock sound buffer! (%x)\n", hr);
 218
 219         size -= dwsize1 + dwsize2;
 220         data += dwsize1 + dwsize2;
 221         This->write_pos += dwsize1 + dwsize2;
 222         if (This->write_pos >= This->buf_size)
 223         {
 224             This->write_pos -= This->buf_size;
 225             This->write_loops++;
 226         }
 227     } while (size && This->state == State_Running);
 228
 229     return hr;
 230 }
 231
 232 static HRESULT DSoundRender_Sample(LPVOID iface, IMediaSample * pSample)
 233 {
 234     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 235     LPBYTE pbSrcStream = NULL;
 236     long cbSrcStream = 0;
 237     REFERENCE_TIME tStart, tStop;
 238     HRESULT hr;
 239
 240     TRACE("%p %p\n", iface, pSample);
 241
 242     /* Slightly incorrect, Pause completes when a frame is received so we should signal
 243      * pause completion here, but for sound playing a single frame doesn't make sense
 244      */
 245
 246     if (This->state == State_Paused)
 247         return S_FALSE;
 248
 249     if (This->state == State_Stopped)
 250         return S_FALSE;
 251
 252     hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
 253     if (FAILED(hr))
 254     {
 255         ERR("Cannot get pointer to sample data (%x)\n", hr);
 256         return hr;
 257     }
 258
 259     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
 260     if (FAILED(hr))
 261         ERR("Cannot get sample time (%x)\n", hr);
 262
 263     if (This->rtLastStop != tStart && (IMediaSample_IsDiscontinuity(pSample) == S_FALSE))
 264         WARN("Unexpected discontinuity: Last: %u.%03u, tStart: %u.%03u\n",
 265             (DWORD)(This->rtLastStop / 10000000), (DWORD)((This->rtLastStop / 10000)%1000),
 266             (DWORD)(tStart / 10000000), (DWORD)((tStart / 10000)%1000));
 267     This->rtLastStop = tStop;
 268
 269     if (IMediaSample_IsPreroll(pSample) == S_OK)
 270     {
 271         TRACE("Preroll!\n");
 272         return S_OK;
 273     }
 274
 275     cbSrcStream = IMediaSample_GetActualDataLength(pSample);
 276     TRACE("Sample data ptr = %p, size = %ld\n", pbSrcStream, cbSrcStream);
 277
 278 #if 0 /* For debugging purpose */
 279     {
 280         int i;
 281         for(i = 0; i < cbSrcStream; i++)
 282         {
 283             if ((i!=0) && !(i%16))
 284                 TRACE("\n");
 285             TRACE("%02x ", pbSrcStream[i]);
 286         }
 287         TRACE("\n");
 288     }
 289 #endif
 290
 291     return DSoundRender_SendSampleData(This, pbSrcStream, cbSrcStream);
 292 }
 293
 294 static HRESULT DSoundRender_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
 295 {
 296     WAVEFORMATEX* format;
 297
 298     if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Audio))
 299         return S_FALSE;
 300
 301     format =  (WAVEFORMATEX*)pmt->pbFormat;
 302     TRACE("Format = %p\n", format);
 303     TRACE("wFormatTag = %x %x\n", format->wFormatTag, WAVE_FORMAT_PCM);
 304     TRACE("nChannels = %d\n", format->nChannels);
 305     TRACE("nSamplesPerSec = %d\n", format->nAvgBytesPerSec);
 306     TRACE("nAvgBytesPerSec = %d\n", format->nAvgBytesPerSec);
 307     TRACE("nBlockAlign = %d\n", format->nBlockAlign);
 308     TRACE("wBitsPerSample = %d\n", format->wBitsPerSample);
 309
 310     if (!IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_PCM))
 311         return S_FALSE;
 312
 313     return S_OK;
 314 }
 315
 316 HRESULT DSoundRender_create(IUnknown * pUnkOuter, LPVOID * ppv)
 317 {
 318     HRESULT hr;
 319     PIN_INFO piInput;
 320     DSoundRenderImpl * pDSoundRender;
 321
 322     TRACE("(%p, %p)\n", pUnkOuter, ppv);
 323
 324     *ppv = NULL;
 325
 326     if (pUnkOuter)
 327         return CLASS_E_NOAGGREGATION;
 328
 329     pDSoundRender = CoTaskMemAlloc(sizeof(DSoundRenderImpl));
 330     if (!pDSoundRender)
 331         return E_OUTOFMEMORY;
 332     ZeroMemory(pDSoundRender, sizeof(DSoundRenderImpl));
 333
 334     pDSoundRender->lpVtbl = &DSoundRender_Vtbl;
 335     pDSoundRender->IBasicAudio_vtbl = &IBasicAudio_Vtbl;
 336     pDSoundRender->IReferenceClock_vtbl = &IReferenceClock_Vtbl;
 337     pDSoundRender->refCount = 1;
 338     InitializeCriticalSection(&pDSoundRender->csFilter);
 339     pDSoundRender->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DSoundRenderImpl.csFilter");
 340     pDSoundRender->state = State_Stopped;
 341
 342     /* construct input pin */
 343     piInput.dir = PINDIR_INPUT;
 344     piInput.pFilter = (IBaseFilter *)pDSoundRender;
 345     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 346     hr = InputPin_Construct(&DSoundRender_InputPin_Vtbl, &piInput, DSoundRender_Sample, pDSoundRender, DSoundRender_QueryAccept, NULL, &pDSoundRender->csFilter, NULL, (IPin **)&pDSoundRender->pInputPin);
 347
 348     if (SUCCEEDED(hr))
 349     {
 350         hr = DirectSoundCreate8(NULL, &pDSoundRender->dsound, NULL);
 351         if (FAILED(hr))
 352             ERR("Cannot create Direct Sound object (%x)\n", hr);
 353         else
 354             IDirectSound_SetCooperativeLevel(pDSoundRender->dsound, GetDesktopWindow(), DSSCL_PRIORITY);
 355     }
 356
 357     if (SUCCEEDED(hr))
 358     {
 359         MediaSeekingImpl_Init((IBaseFilter*)pDSoundRender, sound_mod_stop, sound_mod_start, sound_mod_rate, &pDSoundRender->mediaSeeking, &pDSoundRender->csFilter);
 360         pDSoundRender->mediaSeeking.lpVtbl = &IMediaSeeking_Vtbl;
 361
 362         *ppv = (LPVOID)pDSoundRender;
 363     }
 364     else
 365     {
 366         if (pDSoundRender->pInputPin)
 367             IPin_Release((IPin*)pDSoundRender->pInputPin);
 368         pDSoundRender->csFilter.DebugInfo->Spare[0] = 0;
 369         DeleteCriticalSection(&pDSoundRender->csFilter);
 370         CoTaskMemFree(pDSoundRender);
 371     }
 372
 373     return hr;
 374 }
 375
 376 static HRESULT WINAPI DSoundRender_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 377 {
 378     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 379     TRACE("(%p, %p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 380
 381     *ppv = NULL;
 382
 383     if (IsEqualIID(riid, &IID_IUnknown))
 384         *ppv = (LPVOID)This;
 385     else if (IsEqualIID(riid, &IID_IPersist))
 386         *ppv = (LPVOID)This;
 387     else if (IsEqualIID(riid, &IID_IMediaFilter))
 388         *ppv = (LPVOID)This;
 389     else if (IsEqualIID(riid, &IID_IBaseFilter))
 390         *ppv = (LPVOID)This;
 391     else if (IsEqualIID(riid, &IID_IBasicAudio))
 392         *ppv = (LPVOID)&(This->IBasicAudio_vtbl);
 393     else if (IsEqualIID(riid, &IID_IReferenceClock))
 394         *ppv = (LPVOID)&(This->IReferenceClock_vtbl);
 395     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 396         *ppv = &This->mediaSeeking.lpVtbl;
 397
 398     if (*ppv)
 399     {
 400         IUnknown_AddRef((IUnknown *)(*ppv));
 401         return S_OK;
 402     }
 403
 404     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow))
 405         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 406
 407     return E_NOINTERFACE;
 408 }
 409
 410 static ULONG WINAPI DSoundRender_AddRef(IBaseFilter * iface)
 411 {
 412     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 413     ULONG refCount = InterlockedIncrement(&This->refCount);
 414
 415     TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
 416
 417     return refCount;
 418 }
 419
 420 static ULONG WINAPI DSoundRender_Release(IBaseFilter * iface)
 421 {
 422     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 423     ULONG refCount = InterlockedDecrement(&This->refCount);
 424
 425     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 426
 427     if (!refCount)
 428     {
 429         IPin *pConnectedTo;
 430
 431         if (This->pClock)
 432             IReferenceClock_Release(This->pClock);
 433
 434         if (This->dsbuffer)
 435             IDirectSoundBuffer_Release(This->dsbuffer);
 436         This->dsbuffer = NULL;
 437         if (This->dsound)
 438             IDirectSound_Release(This->dsound);
 439         This->dsound = NULL;
 440
 441         if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo)))
 442         {
 443             IPin_Disconnect(pConnectedTo);
 444             IPin_Release(pConnectedTo);
 445         }
 446         IPin_Disconnect((IPin *)This->pInputPin);
 447
 448         IPin_Release((IPin *)This->pInputPin);
 449
 450         This->lpVtbl = NULL;
 451         This->IBasicAudio_vtbl = NULL;
 452
 453         This->csFilter.DebugInfo->Spare[0] = 0;
 454         DeleteCriticalSection(&This->csFilter);
 455
 456         TRACE("Destroying Audio Renderer\n");
 457         CoTaskMemFree(This);
 458
 459         return 0;
 460     }
 461     else
 462         return refCount;
 463 }
 464
 465 /** IPersist methods **/
 466
 467 static HRESULT WINAPI DSoundRender_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 468 {
 469     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 470     TRACE("(%p/%p)->(%p)\n", This, iface, pClsid);
 471
 472     *pClsid = CLSID_DSoundRender;
 473
 474     return S_OK;
 475 }
 476
 477 /** IMediaFilter methods **/
 478
 479 static HRESULT WINAPI DSoundRender_Stop(IBaseFilter * iface)
 480 {
 481     HRESULT hr = S_OK;
 482     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 483
 484     TRACE("(%p/%p)->()\n", This, iface);
 485
 486     EnterCriticalSection(&This->csFilter);
 487     {
 488         DWORD state = 0;
 489         if (This->dsbuffer)
 490         {
 491             hr = IDirectSoundBuffer_GetStatus(This->dsbuffer, &state);
 492             if (SUCCEEDED(hr))
 493             {
 494                 if (state & DSBSTATUS_PLAYING)
 495                     hr = IDirectSoundBuffer_Stop(This->dsbuffer);
 496             }
 497         }
 498         if (SUCCEEDED(hr))
 499             This->state = State_Stopped;
 500     }
 501     LeaveCriticalSection(&This->csFilter);
 502
 503     return hr;
 504 }
 505
 506 static HRESULT WINAPI DSoundRender_Pause(IBaseFilter * iface)
 507 {
 508     HRESULT hr = S_OK;
 509     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 510
 511     TRACE("(%p/%p)->()\n", This, iface);
 512
 513     EnterCriticalSection(&This->csFilter);
 514     {
 515         DWORD state = 0;
 516         if (This->state == State_Stopped)
 517             This->pInputPin->end_of_stream = 0;
 518
 519         if (This->dsbuffer)
 520         {
 521             hr = IDirectSoundBuffer_GetStatus(This->dsbuffer, &state);
 522             if (SUCCEEDED(hr))
 523             {
 524                 if (state & DSBSTATUS_PLAYING)
 525                     hr = IDirectSoundBuffer_Stop(This->dsbuffer);
 526             }
 527         }
 528         if (SUCCEEDED(hr))
 529             This->state = State_Paused;
 530     }
 531     LeaveCriticalSection(&This->csFilter);
 532
 533     return hr;
 534 }
 535
 536 static HRESULT WINAPI DSoundRender_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 537 {
 538     HRESULT hr = S_OK;
 539     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 540
 541     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
 542
 543     EnterCriticalSection(&This->csFilter);
 544     {
 545         This->rtStreamStart = tStart;
 546         This->state = State_Running;
 547         This->pInputPin->end_of_stream = 0;
 548     }
 549     LeaveCriticalSection(&This->csFilter);
 550
 551     return hr;
 552 }
 553
 554 static HRESULT WINAPI DSoundRender_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 555 {
 556     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 557
 558     TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState);
 559
 560     EnterCriticalSection(&This->csFilter);
 561     {
 562         *pState = This->state;
 563     }
 564     LeaveCriticalSection(&This->csFilter);
 565
 566     return S_OK;
 567 }
 568
 569 static HRESULT WINAPI DSoundRender_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 570 {
 571     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 572
 573     TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
 574
 575     EnterCriticalSection(&This->csFilter);
 576     {
 577         if (This->pClock)
 578             IReferenceClock_Release(This->pClock);
 579         This->pClock = pClock;
 580         if (This->pClock)
 581             IReferenceClock_AddRef(This->pClock);
 582     }
 583     LeaveCriticalSection(&This->csFilter);
 584
 585     return S_OK;
 586 }
 587
 588 static HRESULT WINAPI DSoundRender_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 589 {
 590     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 591
 592     TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
 593
 594     EnterCriticalSection(&This->csFilter);
 595     {
 596         *ppClock = This->pClock;
 597         if (This->pClock)
 598             IReferenceClock_AddRef(This->pClock);
 599     }
 600     LeaveCriticalSection(&This->csFilter);
 601
 602     return S_OK;
 603 }
 604
 605 /** IBaseFilter implementation **/
 606
 607 static HRESULT DSoundRender_GetPin(IBaseFilter *iface, ULONG pos, IPin **pin, DWORD *lastsynctick)
 608 {
 609     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 610
 611     /* Our pins are static, not changing so setting static tick count is ok */
 612     *lastsynctick = 0;
 613
 614     if (pos >= 1)
 615         return S_FALSE;
 616
 617     *pin = (IPin *)This->pInputPin;
 618     IPin_AddRef(*pin);
 619     return S_OK;
 620 }
 621
 622 static HRESULT WINAPI DSoundRender_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 623 {
 624     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 625
 626     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 627
 628     return IEnumPinsImpl_Construct(ppEnum, DSoundRender_GetPin, iface);
 629 }
 630
 631 static HRESULT WINAPI DSoundRender_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 632 {
 633     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 634
 635     TRACE("(%p/%p)->(%s,%p)\n", This, iface, debugstr_w(Id), ppPin);
 636
 637     FIXME("DSoundRender::FindPin(...)\n");
 638
 639     /* FIXME: critical section */
 640
 641     return E_NOTIMPL;
 642 }
 643
 644 static HRESULT WINAPI DSoundRender_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 645 {
 646     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 647
 648     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 649
 650     strcpyW(pInfo->achName, This->filterInfo.achName);
 651     pInfo->pGraph = This->filterInfo.pGraph;
 652
 653     if (pInfo->pGraph)
 654         IFilterGraph_AddRef(pInfo->pGraph);
 655
 656     return S_OK;
 657 }
 658
 659 static HRESULT WINAPI DSoundRender_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 660 {
 661     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 662
 663     TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName));
 664
 665     EnterCriticalSection(&This->csFilter);
 666     {
 667         if (pName)
 668             strcpyW(This->filterInfo.achName, pName);
 669         else
 670             *This->filterInfo.achName = '\0';
 671         This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
 672     }
 673     LeaveCriticalSection(&This->csFilter);
 674
 675     return S_OK;
 676 }
 677
 678 static HRESULT WINAPI DSoundRender_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 679 {
 680     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 681     TRACE("(%p/%p)->(%p)\n", This, iface, pVendorInfo);
 682     return E_NOTIMPL;
 683 }
 684
 685 static const IBaseFilterVtbl DSoundRender_Vtbl =
 686 {
 687     DSoundRender_QueryInterface,
 688     DSoundRender_AddRef,
 689     DSoundRender_Release,
 690     DSoundRender_GetClassID,
 691     DSoundRender_Stop,
 692     DSoundRender_Pause,
 693     DSoundRender_Run,
 694     DSoundRender_GetState,
 695     DSoundRender_SetSyncSource,
 696     DSoundRender_GetSyncSource,
 697     DSoundRender_EnumPins,
 698     DSoundRender_FindPin,
 699     DSoundRender_QueryFilterInfo,
 700     DSoundRender_JoinFilterGraph,
 701     DSoundRender_QueryVendorInfo
 702 };
 703
 704 static HRESULT WINAPI DSoundRender_InputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 705 {
 706     InputPin *This = (InputPin *)iface;
 707     PIN_DIRECTION pindirReceive;
 708     DSoundRenderImpl *DSImpl;
 709     HRESULT hr = S_OK;
 710
 711     TRACE("(%p)->(%p, %p)\n", This, pReceivePin, pmt);
 712     dump_AM_MEDIA_TYPE(pmt);
 713
 714     EnterCriticalSection(This->pin.pCritSec);
 715     {
 716         DSImpl = (DSoundRenderImpl*)This->pin.pinInfo.pFilter;
 717         DSImpl->rtLastStop = -1;
 718
 719         if (This->pin.pConnectedTo)
 720             hr = VFW_E_ALREADY_CONNECTED;
 721
 722         if (SUCCEEDED(hr) && This->pin.fnQueryAccept(This->pin.pUserData, pmt) != S_OK)
 723             hr = VFW_E_TYPE_NOT_ACCEPTED;
 724
 725         if (SUCCEEDED(hr))
 726         {
 727             IPin_QueryDirection(pReceivePin, &pindirReceive);
 728
 729             if (pindirReceive != PINDIR_OUTPUT)
 730             {
 731                 ERR("Can't connect from non-output pin\n");
 732                 hr = VFW_E_INVALID_DIRECTION;
 733             }
 734         }
 735
 736         if (SUCCEEDED(hr))
 737         {
 738             WAVEFORMATEX *format;
 739             DSBUFFERDESC buf_desc;
 740
 741             TRACE("MajorType %s\n", debugstr_guid(&pmt->majortype));
 742             TRACE("SubType %s\n", debugstr_guid(&pmt->subtype));
 743             TRACE("Format %s\n", debugstr_guid(&pmt->formattype));
 744             TRACE("Size %d\n", pmt->cbFormat);
 745
 746             format = (WAVEFORMATEX*)pmt->pbFormat;
 747
 748             DSImpl->buf_size = format->nAvgBytesPerSec;
 749
 750             memset(&buf_desc,0,sizeof(DSBUFFERDESC));
 751             buf_desc.dwSize = sizeof(DSBUFFERDESC);
 752             buf_desc.dwFlags = DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN |
 753                                DSBCAPS_CTRLFREQUENCY |
 754                                DSBCAPS_GETCURRENTPOSITION2;
 755             buf_desc.dwBufferBytes = DSImpl->buf_size;
 756             buf_desc.lpwfxFormat = format;
 757             hr = IDirectSound_CreateSoundBuffer(DSImpl->dsound, &buf_desc, &DSImpl->dsbuffer, NULL);
 758             if (FAILED(hr))
 759                 ERR("Can't create sound buffer (%x)\n", hr);
 760         }
 761
 762         if (SUCCEEDED(hr))
 763         {
 764             hr = IDirectSoundBuffer_SetVolume(DSImpl->dsbuffer, DSImpl->volume);
 765             if (FAILED(hr))
 766                 ERR("Can't set volume to %ld (%x)\n", DSImpl->volume, hr);
 767
 768             hr = IDirectSoundBuffer_SetPan(DSImpl->dsbuffer, DSImpl->pan);
 769             if (FAILED(hr))
 770                 ERR("Can't set pan to %ld (%x)\n", DSImpl->pan, hr);
 771
 772             DSImpl->write_pos = 0;
 773             hr = S_OK;
 774         }
 775
 776         if (SUCCEEDED(hr))
 777         {
 778             CopyMediaType(&This->pin.mtCurrent, pmt);
 779             This->pin.pConnectedTo = pReceivePin;
 780             IPin_AddRef(pReceivePin);
 781         }
 782         else if (hr != VFW_E_ALREADY_CONNECTED)
 783         {
 784             if (DSImpl->dsbuffer)
 785                 IDirectSoundBuffer_Release(DSImpl->dsbuffer);
 786             DSImpl->dsbuffer = NULL;
 787         }
 788     }
 789     LeaveCriticalSection(This->pin.pCritSec);
 790
 791     return hr;
 792 }
 793
 794 static HRESULT WINAPI DSoundRender_InputPin_Disconnect(IPin * iface)
 795 {
 796     IPinImpl *This = (IPinImpl*)iface;
 797     DSoundRenderImpl *DSImpl;
 798
 799     TRACE("(%p)->()\n", iface);
 800
 801     DSImpl = (DSoundRenderImpl*)This->pinInfo.pFilter;
 802     if (DSImpl->dsbuffer)
 803         IDirectSoundBuffer_Release(DSImpl->dsbuffer);
 804     DSImpl->dsbuffer = NULL;
 805
 806     return IPinImpl_Disconnect(iface);
 807 }
 808
 809 static HRESULT WINAPI DSoundRender_InputPin_EndOfStream(IPin * iface)
 810 {
 811     InputPin* This = (InputPin*)iface;
 812     DSoundRenderImpl *me = (DSoundRenderImpl*)This->pin.pinInfo.pFilter;
 813     IMediaEventSink* pEventSink;
 814     HRESULT hr;
 815
 816     EnterCriticalSection(This->pin.pCritSec);
 817
 818     TRACE("(%p/%p)->()\n", This, iface);
 819     InputPin_EndOfStream(iface);
 820
 821     hr = IFilterGraph_QueryInterface(me->filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
 822     if (SUCCEEDED(hr))
 823     {
 824         BYTE * silence;
 825
 826         silence = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, me->buf_size);
 827         if (silence)
 828         {
 829             memset(silence, 0, me->buf_size);
 830             DSoundRender_SendSampleData((DSoundRenderImpl*)This->pin.pinInfo.pFilter, silence, me->buf_size);
 831             HeapFree(GetProcessHeap(), 0, silence);
 832         }
 833
 834         hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, 0);
 835         IMediaEventSink_Release(pEventSink);
 836     }
 837     LeaveCriticalSection(This->pin.pCritSec);
 838
 839     return hr;
 840 }
 841
 842 static HRESULT WINAPI DSoundRender_InputPin_BeginFlush(IPin * iface)
 843 {
 844     InputPin *This = (InputPin *)iface;
 845     DSoundRenderImpl *pFilter = (DSoundRenderImpl *)This->pin.pinInfo.pFilter;
 846     HRESULT hr;
 847     LPBYTE buffer;
 848     DWORD size;
 849
 850     TRACE("\n");
 851
 852     EnterCriticalSection(This->pin.pCritSec);
 853     hr = InputPin_BeginFlush(iface);
 854
 855     if (pFilter->dsbuffer)
 856     {
 857         IDirectSoundBuffer_Stop(pFilter->dsbuffer);
 858
 859         /* Force a reset */
 860         IDirectSoundBuffer_SetCurrentPosition(pFilter->dsbuffer, 0);
 861         pFilter->write_pos = pFilter->last_play_pos = 0;
 862         ++pFilter->play_loops;
 863         pFilter->write_loops = pFilter->play_loops;
 864
 865         IDirectSoundBuffer_Lock(pFilter->dsbuffer, 0, 0, (LPVOID *)&buffer, &size, NULL, NULL, DSBLOCK_ENTIREBUFFER);
 866         memset(buffer, 0, size);
 867         IDirectSoundBuffer_Unlock(pFilter->dsbuffer, buffer, size, NULL, 0);
 868     }
 869     LeaveCriticalSection(This->pin.pCritSec);
 870
 871     return hr;
 872 }
 873
 874 static const IPinVtbl DSoundRender_InputPin_Vtbl =
 875 {
 876     InputPin_QueryInterface,
 877     IPinImpl_AddRef,
 878     InputPin_Release,
 879     InputPin_Connect,
 880     DSoundRender_InputPin_ReceiveConnection,
 881     DSoundRender_InputPin_Disconnect,
 882     IPinImpl_ConnectedTo,
 883     IPinImpl_ConnectionMediaType,
 884     IPinImpl_QueryPinInfo,
 885     IPinImpl_QueryDirection,
 886     IPinImpl_QueryId,
 887     IPinImpl_QueryAccept,
 888     IPinImpl_EnumMediaTypes,
 889     IPinImpl_QueryInternalConnections,
 890     DSoundRender_InputPin_EndOfStream,
 891     DSoundRender_InputPin_BeginFlush,
 892     InputPin_EndFlush,
 893     InputPin_NewSegment
 894 };
 895
 896 /*** IUnknown methods ***/
 897 static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface,
 898                                                 REFIID riid,
 899                                                 LPVOID*ppvObj) {
 900     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 901
 902     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 903
 904     return DSoundRender_QueryInterface((IBaseFilter*)This, riid, ppvObj);
 905 }
 906
 907 static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) {
 908     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 909
 910     TRACE("(%p/%p)->()\n", This, iface);
 911
 912     return DSoundRender_AddRef((IBaseFilter*)This);
 913 }
 914
 915 static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) {
 916     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 917
 918     TRACE("(%p/%p)->()\n", This, iface);
 919
 920     return DSoundRender_Release((IBaseFilter*)This);
 921 }
 922
 923 /*** IDispatch methods ***/
 924 static HRESULT WINAPI Basicaudio_GetTypeInfoCount(IBasicAudio *iface,
 925                                                   UINT*pctinfo) {
 926     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 927
 928     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
 929
 930     return S_OK;
 931 }
 932
 933 static HRESULT WINAPI Basicaudio_GetTypeInfo(IBasicAudio *iface,
 934                                              UINT iTInfo,
 935                                              LCID lcid,
 936                                              ITypeInfo**ppTInfo) {
 937     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 938
 939     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
 940
 941     return S_OK;
 942 }
 943
 944 static HRESULT WINAPI Basicaudio_GetIDsOfNames(IBasicAudio *iface,
 945                                                REFIID riid,
 946                                                LPOLESTR*rgszNames,
 947                                                UINT cNames,
 948                                                LCID lcid,
 949                                                DISPID*rgDispId) {
 950     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 951
 952     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
 953
 954     return S_OK;
 955 }
 956
 957 static HRESULT WINAPI Basicaudio_Invoke(IBasicAudio *iface,
 958                                         DISPID dispIdMember,
 959                                         REFIID riid,
 960                                         LCID lcid,
 961                                         WORD wFlags,
 962                                         DISPPARAMS*pDispParams,
 963                                         VARIANT*pVarResult,
 964                                         EXCEPINFO*pExepInfo,
 965                                         UINT*puArgErr) {
 966     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 967
 968     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);
 969
 970     return S_OK;
 971 }
 972
 973 /*** IBasicAudio methods ***/
 974 static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface,
 975                                             long lVolume) {
 976     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 977
 978     TRACE("(%p/%p)->(%ld)\n", This, iface, lVolume);
 979
 980     if (lVolume > DSBVOLUME_MAX || lVolume < DSBVOLUME_MIN)
 981         return E_INVALIDARG;
 982
 983     if (This->dsbuffer) {
 984         if (FAILED(IDirectSoundBuffer_SetVolume(This->dsbuffer, lVolume)))
 985             return E_FAIL;
 986     }
 987
 988     This->volume = lVolume;
 989     return S_OK;
 990 }
 991
 992 static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface,
 993                                             long *plVolume) {
 994     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 995
 996     TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
 997
 998     if (!plVolume)
 999         return E_POINTER;
1000
1001     *plVolume = This->volume;
1002     return S_OK;
1003 }
1004
1005 static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface,
1006                                              long lBalance) {
1007     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
1008
1009     TRACE("(%p/%p)->(%ld)\n", This, iface, lBalance);
1010
1011     if (lBalance < DSBPAN_LEFT || lBalance > DSBPAN_RIGHT)
1012         return E_INVALIDARG;
1013
1014     if (This->dsbuffer) {
1015         if (FAILED(IDirectSoundBuffer_SetPan(This->dsbuffer, lBalance)))
1016             return E_FAIL;
1017     }
1018
1019     This->pan = lBalance;
1020     return S_OK;
1021 }
1022
1023 static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface,
1024                                              long *plBalance) {
1025     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
1026
1027     TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
1028
1029     if (!plBalance)
1030         return E_POINTER;
1031
1032     *plBalance = This->pan;
1033     return S_OK;
1034 }
1035
1036 static const IBasicAudioVtbl IBasicAudio_Vtbl =
1037 {
1038     Basicaudio_QueryInterface,
1039     Basicaudio_AddRef,
1040     Basicaudio_Release,
1041     Basicaudio_GetTypeInfoCount,
1042     Basicaudio_GetTypeInfo,
1043     Basicaudio_GetIDsOfNames,
1044     Basicaudio_Invoke,
1045     Basicaudio_put_Volume,
1046     Basicaudio_get_Volume,
1047     Basicaudio_put_Balance,
1048     Basicaudio_get_Balance
1049 };
1050
1051
1052 /*** IUnknown methods ***/
1053 static HRESULT WINAPI ReferenceClock_QueryInterface(IReferenceClock *iface,
1054                                                 REFIID riid,
1055                                                 LPVOID*ppvObj)
1056 {
1057     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1058
1059     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
1060
1061     return DSoundRender_QueryInterface((IBaseFilter*)This, riid, ppvObj);
1062 }
1063
1064 static ULONG WINAPI ReferenceClock_AddRef(IReferenceClock *iface)
1065 {
1066     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1067
1068     TRACE("(%p/%p)->()\n", This, iface);
1069
1070     return DSoundRender_AddRef((IBaseFilter*)This);
1071 }
1072
1073 static ULONG WINAPI ReferenceClock_Release(IReferenceClock *iface)
1074 {
1075     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1076
1077     TRACE("(%p/%p)->()\n", This, iface);
1078
1079     return DSoundRender_Release((IBaseFilter*)This);
1080 }
1081
1082 /*** IReferenceClock methods ***/
1083 static HRESULT WINAPI ReferenceClock_GetTime(IReferenceClock *iface,
1084                                              REFERENCE_TIME *pTime)
1085 {
1086     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1087     HRESULT hr = E_FAIL;
1088     DWORD play_pos;
1089
1090     TRACE("(%p/%p)->(%p)\n", This, iface, pTime);
1091
1092     if (This->dsbuffer)
1093         hr = DSoundRender_GetPos(This, &play_pos, pTime);
1094     if (FAILED(hr))
1095         ERR("Could not get reference time (%x)!\n", hr);
1096
1097     return hr;
1098 }
1099
1100 static HRESULT WINAPI ReferenceClock_AdviseTime(IReferenceClock *iface,
1101                                                 REFERENCE_TIME rtBaseTime,
1102                                                 REFERENCE_TIME rtStreamTime,
1103                                                 HEVENT hEvent,
1104                                                 DWORD_PTR *pdwAdviseCookie)
1105 {
1106     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1107
1108     FIXME("(%p/%p)->(%s, %s, %p, %p): stub!\n", This, iface, wine_dbgstr_longlong(rtBaseTime), wine_dbgstr_longlong(rtStreamTime), (void*)hEvent, pdwAdviseCookie);
1109
1110     return E_NOTIMPL;
1111 }
1112
1113 static HRESULT WINAPI ReferenceClock_AdvisePeriodic(IReferenceClock *iface,
1114                                                     REFERENCE_TIME rtBaseTime,
1115                                                     REFERENCE_TIME rtStreamTime,
1116                                                     HSEMAPHORE hSemaphore,
1117                                                     DWORD_PTR *pdwAdviseCookie)
1118 {
1119     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1120
1121     FIXME("(%p/%p)->(%s, %s, %p, %p): stub!\n", This, iface, wine_dbgstr_longlong(rtBaseTime), wine_dbgstr_longlong(rtStreamTime), (void*)hSemaphore, pdwAdviseCookie);
1122
1123     return E_NOTIMPL;
1124 }
1125
1126 static HRESULT WINAPI ReferenceClock_Unadvise(IReferenceClock *iface,
1127                                               DWORD_PTR dwAdviseCookie)
1128 {
1129     ICOM_THIS_MULTI(DSoundRenderImpl, IReferenceClock_vtbl, iface);
1130
1131     FIXME("(%p/%p)->(%p): stub!\n", This, iface, (void*)dwAdviseCookie);
1132
1133     return S_FALSE;
1134 }
1135
1136 static const IReferenceClockVtbl IReferenceClock_Vtbl =
1137 {
1138     ReferenceClock_QueryInterface,
1139     ReferenceClock_AddRef,
1140     ReferenceClock_Release,
1141     ReferenceClock_GetTime,
1142     ReferenceClock_AdviseTime,
1143     ReferenceClock_AdvisePeriodic,
1144     ReferenceClock_Unadvise
1145 };
1146
1147 static inline DSoundRenderImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
1148 {
1149     return (DSoundRenderImpl *)((char*)iface - FIELD_OFFSET(DSoundRenderImpl, mediaSeeking.lpVtbl));
1150 }
1151
1152 static HRESULT WINAPI sound_seek_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
1153 {
1154     DSoundRenderImpl *This = impl_from_IMediaSeeking(iface);
1155
1156     return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
1157 }
1158
1159 static ULONG WINAPI sound_seek_AddRef(IMediaSeeking * iface)
1160 {
1161     DSoundRenderImpl *This = impl_from_IMediaSeeking(iface);
1162
1163     return IUnknown_AddRef((IUnknown *)This);
1164 }
1165
1166 static ULONG WINAPI sound_seek_Release(IMediaSeeking * iface)
1167 {
1168     DSoundRenderImpl *This = impl_from_IMediaSeeking(iface);
1169
1170     return IUnknown_Release((IUnknown *)This);
1171 }
1172
1173 static const IMediaSeekingVtbl IMediaSeeking_Vtbl =
1174 {
1175     sound_seek_QueryInterface,
1176     sound_seek_AddRef,
1177     sound_seek_Release,
1178     MediaSeekingImpl_GetCapabilities,
1179     MediaSeekingImpl_CheckCapabilities,
1180     MediaSeekingImpl_IsFormatSupported,
1181     MediaSeekingImpl_QueryPreferredFormat,
1182     MediaSeekingImpl_GetTimeFormat,
1183     MediaSeekingImpl_IsUsingTimeFormat,
1184     MediaSeekingImpl_SetTimeFormat,
1185     MediaSeekingImpl_GetDuration,
1186     MediaSeekingImpl_GetStopPosition,
1187     MediaSeekingImpl_GetCurrentPosition,
1188     MediaSeekingImpl_ConvertTimeFormat,
1189     MediaSeekingImpl_SetPositions,
1190     MediaSeekingImpl_GetPositions,
1191     MediaSeekingImpl_GetAvailable,
1192     MediaSeekingImpl_SetRate,
1193     MediaSeekingImpl_GetRate,
1194     MediaSeekingImpl_GetPreroll
1195 };