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 "mmreg.h"
  29 #include "vfwmsgs.h"
  30 #include "fourcc.h"
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "dshow.h"
  34 #include "evcode.h"
  35 #include "strmif.h"
  36 #include "dsound.h"
  37
  38 #include "wine/unicode.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  42
  43 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  44
  45 static const IBaseFilterVtbl DSoundRender_Vtbl;
  46 static const IPinVtbl DSoundRender_InputPin_Vtbl;
  47 static const IMemInputPinVtbl MemInputPin_Vtbl;
  48 static const IBasicAudioVtbl IBasicAudio_Vtbl;
  49
  50 typedef struct DSoundRenderImpl
  51 {
  52     const IBaseFilterVtbl * lpVtbl;
  53     const IBasicAudioVtbl *IBasicAudio_vtbl;
  54
  55     LONG refCount;
  56     CRITICAL_SECTION csFilter;
  57     FILTER_STATE state;
  58     REFERENCE_TIME rtStreamStart;
  59     IReferenceClock * pClock;
  60     FILTER_INFO filterInfo;
  61
  62     InputPin * pInputPin;
  63     IPin ** ppPins;
  64
  65     LPDIRECTSOUND dsound;
  66     LPDIRECTSOUNDBUFFER dsbuffer;
  67     DWORD write_pos;
  68     BOOL init;
  69
  70     long volume;
  71     long pan;
  72 } DSoundRenderImpl;
  73
  74 static HRESULT DSoundRender_InputPin_Construct(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
  75 {
  76     InputPin * pPinImpl;
  77
  78     *ppPin = NULL;
  79
  80     if (pPinInfo->dir != PINDIR_INPUT)
  81     {
  82         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
  83         return E_INVALIDARG;
  84     }
  85
  86     pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
  87
  88     if (!pPinImpl)
  89         return E_OUTOFMEMORY;
  90
  91     if (SUCCEEDED(InputPin_Init(pPinInfo, pSampleProc, pUserData, pQueryAccept, pCritSec, pPinImpl)))
  92     {
  93         pPinImpl->pin.lpVtbl = &DSoundRender_InputPin_Vtbl;
  94         pPinImpl->lpVtblMemInput = &MemInputPin_Vtbl;
  95
  96         *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
  97         return S_OK;
  98     }
  99     return E_FAIL;
 100 }
 101
 102
 103 #define DSBUFFERSIZE 8192
 104
 105 static HRESULT DSoundRender_CreateSoundBuffer(IBaseFilter * iface)
 106 {
 107     HRESULT hr;
 108     WAVEFORMATEX wav_fmt;
 109     AM_MEDIA_TYPE amt;
 110     WAVEFORMATEX* format;
 111     DSBUFFERDESC buf_desc;
 112     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 113
 114     hr = IPin_ConnectionMediaType(This->ppPins[0], &amt);
 115     if (FAILED(hr)) {
 116         ERR("Unable to retrieve media type\n");
 117         return hr;
 118     }
 119
 120     TRACE("MajorType %s\n", debugstr_guid(&amt.majortype));
 121     TRACE("SubType %s\n", debugstr_guid(&amt.subtype));
 122     TRACE("Format %s\n", debugstr_guid(&amt.formattype));
 123     TRACE("Size %d\n", amt.cbFormat);
 124
 125     dump_AM_MEDIA_TYPE(&amt);
 126
 127     format = (WAVEFORMATEX*)amt.pbFormat;
 128     TRACE("wFormatTag = %x %x\n", format->wFormatTag, WAVE_FORMAT_PCM);
 129     TRACE("nChannels = %d\n", format->nChannels);
 130     TRACE("nSamplesPerSec = %u\n", format->nSamplesPerSec);
 131     TRACE("nAvgBytesPerSec = %u\n", format->nAvgBytesPerSec);
 132     TRACE("nBlockAlign = %d\n", format->nBlockAlign);
 133     TRACE("wBitsPerSample = %d\n", format->wBitsPerSample);
 134     TRACE("cbSize = %d\n", format->cbSize);
 135
 136     /* Lock the critical section to make sure we're still marked to play while
 137        setting up the playback buffer */
 138     EnterCriticalSection(&This->csFilter);
 139
 140     if (This->state != State_Running) {
 141         hr = VFW_E_WRONG_STATE;
 142         goto getout;
 143     }
 144
 145     hr = DirectSoundCreate(NULL, &This->dsound, NULL);
 146     if (FAILED(hr)) {
 147         ERR("Cannot create Direct Sound object\n");
 148         goto getout;
 149     }
 150
 151     wav_fmt = *format;
 152     wav_fmt.cbSize = 0;
 153
 154     memset(&buf_desc,0,sizeof(DSBUFFERDESC));
 155     buf_desc.dwSize = sizeof(DSBUFFERDESC);
 156     buf_desc.dwFlags = DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
 157     buf_desc.dwBufferBytes = DSBUFFERSIZE;
 158     buf_desc.lpwfxFormat = &wav_fmt;
 159     hr = IDirectSound_CreateSoundBuffer(This->dsound, &buf_desc, &This->dsbuffer, NULL);
 160     if (FAILED(hr)) {
 161         ERR("Can't create sound buffer !\n");
 162         IDirectSound_Release(This->dsound);
 163         goto getout;
 164     }
 165
 166     hr = IDirectSoundBuffer_SetVolume(This->dsbuffer, This->volume);
 167     if (FAILED(hr))
 168         ERR("Can't set volume to %ld (%x)!\n", This->volume, hr);
 169
 170     hr = IDirectSoundBuffer_SetPan(This->dsbuffer, This->pan);
 171     if (FAILED(hr))
 172         ERR("Can't set pan to %ld (%x)!\n", This->pan, hr);
 173
 174     hr = IDirectSoundBuffer_Play(This->dsbuffer, 0, 0, DSBPLAY_LOOPING);
 175     if (FAILED(hr)) {
 176         ERR("Can't start sound buffer (%x)!\n", hr);
 177         IDirectSoundBuffer_Release(This->dsbuffer);
 178         IDirectSound_Release(This->dsound);
 179         goto getout;
 180     }
 181
 182     This->write_pos = 0;
 183
 184 getout:
 185     LeaveCriticalSection(&This->csFilter);
 186     return hr;
 187 }
 188
 189 static HRESULT DSoundRender_SendSampleData(DSoundRenderImpl* This, LPBYTE data, DWORD size)
 190 {
 191     HRESULT hr;
 192     LPBYTE lpbuf1 = NULL;
 193     LPBYTE lpbuf2 = NULL;
 194     DWORD dwsize1 = 0;
 195     DWORD dwsize2 = 0;
 196     DWORD size2;
 197     DWORD play_pos,buf_free;
 198
 199     do {
 200         hr = IDirectSoundBuffer_GetCurrentPosition(This->dsbuffer, &play_pos, NULL);
 201         if (hr != DS_OK)
 202         {
 203             ERR("Error GetCurrentPosition: %x\n", hr);
 204             break;
 205         }
 206         if (This->write_pos < play_pos)
 207              buf_free = play_pos-This->write_pos;
 208         else
 209              buf_free = DSBUFFERSIZE - This->write_pos + play_pos;
 210
 211         /* This situation is ambiguous; Assume full when playing */
 212         if(buf_free == DSBUFFERSIZE)
 213         {
 214             Sleep(10);
 215             continue;
 216         }
 217
 218         size2 = min(buf_free, size);
 219         hr = IDirectSoundBuffer_Lock(This->dsbuffer, This->write_pos, size2, (LPVOID *)&lpbuf1, &dwsize1, (LPVOID *)&lpbuf2, &dwsize2, 0);
 220         if (hr != DS_OK) {
 221             ERR("Unable to lock sound buffer! (%x)\n", hr);
 222             break;
 223         }
 224         /* TRACE("write_pos=%d, size=%d, sz1=%d, sz2=%d\n", This->write_pos, size2, dwsize1, dwsize2); */
 225
 226         memcpy(lpbuf1, data, dwsize1);
 227         if (dwsize2)
 228             memcpy(lpbuf2, data + dwsize1, dwsize2);
 229
 230         hr = IDirectSoundBuffer_Unlock(This->dsbuffer, lpbuf1, dwsize1, lpbuf2, dwsize2);
 231         if (hr != DS_OK)
 232             ERR("Unable to unlock sound buffer! (%x)\n", hr);
 233
 234         size -= dwsize1 + dwsize2;
 235         data += dwsize1 + dwsize2;
 236         This->write_pos = (This->write_pos + dwsize1 + dwsize2) % DSBUFFERSIZE;
 237
 238         if (!size)
 239             break;
 240         Sleep(10);
 241     } while (This->state == State_Running);
 242
 243     return hr;
 244 }
 245
 246 static HRESULT DSoundRender_Sample(LPVOID iface, IMediaSample * pSample)
 247 {
 248     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 249     LPBYTE pbSrcStream = NULL;
 250     long cbSrcStream = 0;
 251     REFERENCE_TIME tStart, tStop;
 252     HRESULT hr;
 253
 254     TRACE("%p %p\n", iface, pSample);
 255
 256     if (This->state != State_Running)
 257         return VFW_E_WRONG_STATE;
 258
 259     hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
 260     if (FAILED(hr))
 261     {
 262         ERR("Cannot get pointer to sample data (%x)\n", hr);
 263         return hr;
 264     }
 265
 266     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
 267     if (FAILED(hr))
 268         ERR("Cannot get sample time (%x)\n", hr);
 269
 270     cbSrcStream = IMediaSample_GetActualDataLength(pSample);
 271
 272     TRACE("Sample data ptr = %p, size = %ld\n", pbSrcStream, cbSrcStream);
 273
 274 #if 0 /* For debugging purpose */
 275     {
 276         int i;
 277         for(i = 0; i < cbSrcStream; i++)
 278         {
 279             if ((i!=0) && !(i%16))
 280                 TRACE("\n");
 281             TRACE("%02x ", pbSrcStream[i]);
 282         }
 283         TRACE("\n");
 284     }
 285 #endif
 286
 287     if (!This->init)
 288     {
 289         hr = DSoundRender_CreateSoundBuffer(iface);
 290         if (SUCCEEDED(hr))
 291             This->init = TRUE;
 292         else
 293         {
 294             ERR("Unable to create DSound buffer\n");
 295             return hr;
 296         }
 297     }
 298
 299     hr = DSoundRender_SendSampleData(This, pbSrcStream, cbSrcStream);
 300
 301     return hr;
 302 }
 303
 304 static HRESULT DSoundRender_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
 305 {
 306     WAVEFORMATEX* format = (WAVEFORMATEX*)pmt->pbFormat;
 307     TRACE("wFormatTag = %x %x\n", format->wFormatTag, WAVE_FORMAT_PCM);
 308     TRACE("nChannels = %d\n", format->nChannels);
 309     TRACE("nSamplesPerSec = %d\n", format->nAvgBytesPerSec);
 310     TRACE("nAvgBytesPerSec = %d\n", format->nAvgBytesPerSec);
 311     TRACE("nBlockAlign = %d\n", format->nBlockAlign);
 312     TRACE("wBitsPerSample = %d\n", format->wBitsPerSample);
 313
 314     if (IsEqualIID(&pmt->majortype, &MEDIATYPE_Audio) && IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_PCM))
 315         return S_OK;
 316     return S_FALSE;
 317 }
 318
 319 HRESULT DSoundRender_create(IUnknown * pUnkOuter, LPVOID * ppv)
 320 {
 321     HRESULT hr;
 322     PIN_INFO piInput;
 323     DSoundRenderImpl * pDSoundRender;
 324
 325     TRACE("(%p, %p)\n", pUnkOuter, ppv);
 326
 327     *ppv = NULL;
 328
 329     if (pUnkOuter)
 330         return CLASS_E_NOAGGREGATION;
 331
 332     pDSoundRender = CoTaskMemAlloc(sizeof(DSoundRenderImpl));
 333     if (!pDSoundRender)
 334         return E_OUTOFMEMORY;
 335     ZeroMemory(pDSoundRender, sizeof(DSoundRenderImpl));
 336
 337     pDSoundRender->lpVtbl = &DSoundRender_Vtbl;
 338     pDSoundRender->IBasicAudio_vtbl = &IBasicAudio_Vtbl;
 339     pDSoundRender->refCount = 1;
 340     InitializeCriticalSection(&pDSoundRender->csFilter);
 341     pDSoundRender->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DSoundRenderImpl.csFilter");
 342     pDSoundRender->state = State_Stopped;
 343
 344     pDSoundRender->ppPins = CoTaskMemAlloc(1 * sizeof(IPin *));
 345     if (!pDSoundRender->ppPins)
 346     {
 347         pDSoundRender->csFilter.DebugInfo->Spare[0] = 0;
 348         DeleteCriticalSection(&pDSoundRender->csFilter);
 349         CoTaskMemFree(pDSoundRender);
 350         return E_OUTOFMEMORY;
 351     }
 352
 353     /* construct input pin */
 354     piInput.dir = PINDIR_INPUT;
 355     piInput.pFilter = (IBaseFilter *)pDSoundRender;
 356     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 357     hr = DSoundRender_InputPin_Construct(&piInput, DSoundRender_Sample, (LPVOID)pDSoundRender, DSoundRender_QueryAccept, &pDSoundRender->csFilter, (IPin **)&pDSoundRender->pInputPin);
 358
 359     if (SUCCEEDED(hr))
 360     {
 361         pDSoundRender->ppPins[0] = (IPin *)pDSoundRender->pInputPin;
 362         *ppv = (LPVOID)pDSoundRender;
 363     }
 364     else
 365     {
 366         CoTaskMemFree(pDSoundRender->ppPins);
 367         pDSoundRender->csFilter.DebugInfo->Spare[0] = 0;
 368         DeleteCriticalSection(&pDSoundRender->csFilter);
 369         CoTaskMemFree(pDSoundRender);
 370     }
 371
 372     return hr;
 373 }
 374
 375 static HRESULT WINAPI DSoundRender_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 376 {
 377     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 378     TRACE("(%p, %p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 379
 380     *ppv = NULL;
 381
 382     if (IsEqualIID(riid, &IID_IUnknown))
 383         *ppv = (LPVOID)This;
 384     else if (IsEqualIID(riid, &IID_IPersist))
 385         *ppv = (LPVOID)This;
 386     else if (IsEqualIID(riid, &IID_IMediaFilter))
 387         *ppv = (LPVOID)This;
 388     else if (IsEqualIID(riid, &IID_IBaseFilter))
 389         *ppv = (LPVOID)This;
 390     else if (IsEqualIID(riid, &IID_IBasicAudio))
 391         *ppv = (LPVOID)&(This->IBasicAudio_vtbl);
 392
 393     if (*ppv)
 394     {
 395         IUnknown_AddRef((IUnknown *)(*ppv));
 396         return S_OK;
 397     }
 398
 399     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 400
 401     return E_NOINTERFACE;
 402 }
 403
 404 static ULONG WINAPI DSoundRender_AddRef(IBaseFilter * iface)
 405 {
 406     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 407     ULONG refCount = InterlockedIncrement(&This->refCount);
 408
 409     TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
 410
 411     return refCount;
 412 }
 413
 414 static ULONG WINAPI DSoundRender_Release(IBaseFilter * iface)
 415 {
 416     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 417     ULONG refCount = InterlockedDecrement(&This->refCount);
 418
 419     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 420
 421     if (!refCount)
 422     {
 423         IPin *pConnectedTo;
 424
 425         if (This->pClock)
 426             IReferenceClock_Release(This->pClock);
 427
 428         if (This->dsbuffer)
 429             IDirectSoundBuffer_Release(This->dsbuffer);
 430         This->dsbuffer = NULL;
 431         if (This->dsound)
 432             IDirectSound_Release(This->dsound);
 433         This->dsound = NULL;
 434
 435         if (SUCCEEDED(IPin_ConnectedTo(This->ppPins[0], &pConnectedTo)))
 436         {
 437             IPin_Disconnect(pConnectedTo);
 438             IPin_Release(pConnectedTo);
 439         }
 440         IPin_Disconnect(This->ppPins[0]);
 441
 442         IPin_Release(This->ppPins[0]);
 443
 444         CoTaskMemFree(This->ppPins);
 445         This->lpVtbl = NULL;
 446         This->IBasicAudio_vtbl = NULL;
 447
 448         This->csFilter.DebugInfo->Spare[0] = 0;
 449         DeleteCriticalSection(&This->csFilter);
 450
 451         TRACE("Destroying Audio Renderer\n");
 452         CoTaskMemFree(This);
 453
 454         return 0;
 455     }
 456     else
 457         return refCount;
 458 }
 459
 460 /** IPersist methods **/
 461
 462 static HRESULT WINAPI DSoundRender_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 463 {
 464     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 465     TRACE("(%p/%p)->(%p)\n", This, iface, pClsid);
 466
 467     *pClsid = CLSID_DSoundRender;
 468
 469     return S_OK;
 470 }
 471
 472 /** IMediaFilter methods **/
 473
 474 static HRESULT WINAPI DSoundRender_Stop(IBaseFilter * iface)
 475 {
 476     HRESULT hr = S_OK;
 477     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 478
 479     TRACE("(%p/%p)->()\n", This, iface);
 480
 481     EnterCriticalSection(&This->csFilter);
 482     {
 483         DWORD state = 0;
 484         if (This->dsbuffer)
 485         {
 486             hr = IDirectSoundBuffer_GetStatus(This->dsbuffer, &state);
 487             if (SUCCEEDED(hr))
 488             {
 489                 if (state & DSBSTATUS_PLAYING)
 490                     hr = IDirectSoundBuffer_Stop(This->dsbuffer);
 491             }
 492         }
 493         if (SUCCEEDED(hr))
 494             This->state = State_Stopped;
 495     }
 496     LeaveCriticalSection(&This->csFilter);
 497
 498     return hr;
 499 }
 500
 501 static HRESULT WINAPI DSoundRender_Pause(IBaseFilter * iface)
 502 {
 503     HRESULT hr = S_OK;
 504     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 505
 506     TRACE("(%p/%p)->()\n", This, iface);
 507
 508     EnterCriticalSection(&This->csFilter);
 509     {
 510         DWORD state = 0;
 511         if (This->dsbuffer)
 512         {
 513             hr = IDirectSoundBuffer_GetStatus(This->dsbuffer, &state);
 514             if (SUCCEEDED(hr))
 515             {
 516                 if (state & DSBSTATUS_PLAYING)
 517                     hr = IDirectSoundBuffer_Stop(This->dsbuffer);
 518             }
 519         }
 520         if (SUCCEEDED(hr))
 521             This->state = State_Paused;
 522     }
 523     LeaveCriticalSection(&This->csFilter);
 524
 525     return hr;
 526 }
 527
 528 static HRESULT WINAPI DSoundRender_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 529 {
 530     HRESULT hr = S_OK;
 531     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 532
 533     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
 534
 535     EnterCriticalSection(&This->csFilter);
 536     {
 537         /* It's okay if there's no buffer yet. It'll start when it's created */
 538         if (This->dsbuffer)
 539         {
 540             hr = IDirectSoundBuffer_Play(This->dsbuffer, 0, 0, DSBPLAY_LOOPING);
 541             if (FAILED(hr))
 542                 ERR("Can't start playing! (%x)\n", hr);
 543         }
 544         if (SUCCEEDED(hr))
 545         {
 546             This->rtStreamStart = tStart;
 547             This->state = State_Running;
 548         }
 549     }
 550     LeaveCriticalSection(&This->csFilter);
 551
 552     return hr;
 553 }
 554
 555 static HRESULT WINAPI DSoundRender_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 556 {
 557     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 558
 559     TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState);
 560
 561     EnterCriticalSection(&This->csFilter);
 562     {
 563         *pState = This->state;
 564     }
 565     LeaveCriticalSection(&This->csFilter);
 566
 567     return S_OK;
 568 }
 569
 570 static HRESULT WINAPI DSoundRender_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 571 {
 572     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 573
 574     TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
 575
 576     EnterCriticalSection(&This->csFilter);
 577     {
 578         if (This->pClock)
 579             IReferenceClock_Release(This->pClock);
 580         This->pClock = pClock;
 581         if (This->pClock)
 582             IReferenceClock_AddRef(This->pClock);
 583     }
 584     LeaveCriticalSection(&This->csFilter);
 585
 586     return S_OK;
 587 }
 588
 589 static HRESULT WINAPI DSoundRender_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 590 {
 591     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 592
 593     TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
 594
 595     EnterCriticalSection(&This->csFilter);
 596     {
 597         *ppClock = 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 WINAPI DSoundRender_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 608 {
 609     ENUMPINDETAILS epd;
 610     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 611
 612     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 613
 614     epd.cPins = 1; /* input pin */
 615     epd.ppPins = This->ppPins;
 616     return IEnumPinsImpl_Construct(&epd, ppEnum);
 617 }
 618
 619 static HRESULT WINAPI DSoundRender_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 620 {
 621     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 622
 623     TRACE("(%p/%p)->(%s,%p)\n", This, iface, debugstr_w(Id), ppPin);
 624
 625     FIXME("DSoundRender::FindPin(...)\n");
 626
 627     /* FIXME: critical section */
 628
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI DSoundRender_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 633 {
 634     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 635
 636     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 637
 638     strcpyW(pInfo->achName, This->filterInfo.achName);
 639     pInfo->pGraph = This->filterInfo.pGraph;
 640
 641     if (pInfo->pGraph)
 642         IFilterGraph_AddRef(pInfo->pGraph);
 643
 644     return S_OK;
 645 }
 646
 647 static HRESULT WINAPI DSoundRender_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 648 {
 649     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 650
 651     TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName));
 652
 653     EnterCriticalSection(&This->csFilter);
 654     {
 655         if (pName)
 656             strcpyW(This->filterInfo.achName, pName);
 657         else
 658             *This->filterInfo.achName = '\0';
 659         This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
 660     }
 661     LeaveCriticalSection(&This->csFilter);
 662
 663     return S_OK;
 664 }
 665
 666 static HRESULT WINAPI DSoundRender_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 667 {
 668     DSoundRenderImpl *This = (DSoundRenderImpl *)iface;
 669     TRACE("(%p/%p)->(%p)\n", This, iface, pVendorInfo);
 670     return E_NOTIMPL;
 671 }
 672
 673 static const IBaseFilterVtbl DSoundRender_Vtbl =
 674 {
 675     DSoundRender_QueryInterface,
 676     DSoundRender_AddRef,
 677     DSoundRender_Release,
 678     DSoundRender_GetClassID,
 679     DSoundRender_Stop,
 680     DSoundRender_Pause,
 681     DSoundRender_Run,
 682     DSoundRender_GetState,
 683     DSoundRender_SetSyncSource,
 684     DSoundRender_GetSyncSource,
 685     DSoundRender_EnumPins,
 686     DSoundRender_FindPin,
 687     DSoundRender_QueryFilterInfo,
 688     DSoundRender_JoinFilterGraph,
 689     DSoundRender_QueryVendorInfo
 690 };
 691
 692 static HRESULT WINAPI DSoundRender_InputPin_EndOfStream(IPin * iface)
 693 {
 694     InputPin* This = (InputPin*)iface;
 695     IMediaEventSink* pEventSink;
 696     HRESULT hr;
 697
 698     TRACE("(%p/%p)->()\n", This, iface);
 699
 700     hr = IFilterGraph_QueryInterface(((DSoundRenderImpl*)This->pin.pinInfo.pFilter)->filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink);
 701     if (SUCCEEDED(hr))
 702     {
 703         /* FIXME: We should wait that all audio data has been played */
 704         hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, 0);
 705         IMediaEventSink_Release(pEventSink);
 706     }
 707
 708     return hr;
 709 }
 710
 711 static const IPinVtbl DSoundRender_InputPin_Vtbl =
 712 {
 713     InputPin_QueryInterface,
 714     IPinImpl_AddRef,
 715     InputPin_Release,
 716     InputPin_Connect,
 717     InputPin_ReceiveConnection,
 718     IPinImpl_Disconnect,
 719     IPinImpl_ConnectedTo,
 720     IPinImpl_ConnectionMediaType,
 721     IPinImpl_QueryPinInfo,
 722     IPinImpl_QueryDirection,
 723     IPinImpl_QueryId,
 724     IPinImpl_QueryAccept,
 725     IPinImpl_EnumMediaTypes,
 726     IPinImpl_QueryInternalConnections,
 727     DSoundRender_InputPin_EndOfStream,
 728     InputPin_BeginFlush,
 729     InputPin_EndFlush,
 730     InputPin_NewSegment
 731 };
 732
 733 static const IMemInputPinVtbl MemInputPin_Vtbl =
 734 {
 735     MemInputPin_QueryInterface,
 736     MemInputPin_AddRef,
 737     MemInputPin_Release,
 738     MemInputPin_GetAllocator,
 739     MemInputPin_NotifyAllocator,
 740     MemInputPin_GetAllocatorRequirements,
 741     MemInputPin_Receive,
 742     MemInputPin_ReceiveMultiple,
 743     MemInputPin_ReceiveCanBlock
 744 };
 745
 746 /*** IUnknown methods ***/
 747 static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface,
 748                                                 REFIID riid,
 749                                                 LPVOID*ppvObj) {
 750     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 751
 752     TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj);
 753
 754     return DSoundRender_QueryInterface((IBaseFilter*)This, riid, ppvObj);
 755 }
 756
 757 static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) {
 758     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 759
 760     TRACE("(%p/%p)->()\n", This, iface);
 761
 762     return DSoundRender_AddRef((IBaseFilter*)This);
 763 }
 764
 765 static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) {
 766     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 767
 768     TRACE("(%p/%p)->()\n", This, iface);
 769
 770     return DSoundRender_Release((IBaseFilter*)This);
 771 }
 772
 773 /*** IDispatch methods ***/
 774 static HRESULT WINAPI Basicaudio_GetTypeInfoCount(IBasicAudio *iface,
 775                                                   UINT*pctinfo) {
 776     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 777
 778     TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo);
 779
 780     return S_OK;
 781 }
 782
 783 static HRESULT WINAPI Basicaudio_GetTypeInfo(IBasicAudio *iface,
 784                                              UINT iTInfo,
 785                                              LCID lcid,
 786                                              ITypeInfo**ppTInfo) {
 787     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 788
 789     TRACE("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo);
 790
 791     return S_OK;
 792 }
 793
 794 static HRESULT WINAPI Basicaudio_GetIDsOfNames(IBasicAudio *iface,
 795                                                REFIID riid,
 796                                                LPOLESTR*rgszNames,
 797                                                UINT cNames,
 798                                                LCID lcid,
 799                                                DISPID*rgDispId) {
 800     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 801
 802     TRACE("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId);
 803
 804     return S_OK;
 805 }
 806
 807 static HRESULT WINAPI Basicaudio_Invoke(IBasicAudio *iface,
 808                                         DISPID dispIdMember,
 809                                         REFIID riid,
 810                                         LCID lcid,
 811                                         WORD wFlags,
 812                                         DISPPARAMS*pDispParams,
 813                                         VARIANT*pVarResult,
 814                                         EXCEPINFO*pExepInfo,
 815                                         UINT*puArgErr) {
 816     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 817
 818     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);
 819
 820     return S_OK;
 821 }
 822
 823 /*** IBasicAudio methods ***/
 824 static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface,
 825                                             long lVolume) {
 826     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 827
 828     TRACE("(%p/%p)->(%ld)\n", This, iface, lVolume);
 829
 830     if (lVolume > DSBVOLUME_MAX || lVolume < DSBVOLUME_MIN)
 831         return E_INVALIDARG;
 832
 833     if (This->dsbuffer) {
 834         if (FAILED(IDirectSoundBuffer_SetVolume(This->dsbuffer, lVolume)))
 835             return E_FAIL;
 836     }
 837
 838     This->volume = lVolume;
 839     return S_OK;
 840 }
 841
 842 static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface,
 843                                             long *plVolume) {
 844     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 845
 846     TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
 847
 848     if (!plVolume)
 849         return E_POINTER;
 850
 851     *plVolume = This->volume;
 852     return S_OK;
 853 }
 854
 855 static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface,
 856                                              long lBalance) {
 857     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 858
 859     TRACE("(%p/%p)->(%ld)\n", This, iface, lBalance);
 860
 861     if (lBalance < DSBPAN_LEFT || lBalance > DSBPAN_RIGHT)
 862         return E_INVALIDARG;
 863
 864     if (This->dsbuffer) {
 865         if (FAILED(IDirectSoundBuffer_SetPan(This->dsbuffer, lBalance)))
 866             return E_FAIL;
 867     }
 868
 869     This->pan = lBalance;
 870     return S_OK;
 871 }
 872
 873 static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface,
 874                                              long *plBalance) {
 875     ICOM_THIS_MULTI(DSoundRenderImpl, IBasicAudio_vtbl, iface);
 876
 877     TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
 878
 879     if (!plBalance)
 880         return E_POINTER;
 881
 882     *plBalance = This->pan;
 883     return S_OK;
 884 }
 885
 886 static const IBasicAudioVtbl IBasicAudio_Vtbl =
 887 {
 888     Basicaudio_QueryInterface,
 889     Basicaudio_AddRef,
 890     Basicaudio_Release,
 891     Basicaudio_GetTypeInfoCount,
 892     Basicaudio_GetTypeInfo,
 893     Basicaudio_GetIDsOfNames,
 894     Basicaudio_Invoke,
 895     Basicaudio_put_Volume,
 896     Basicaudio_get_Volume,
 897     Basicaudio_put_Balance,
 898     Basicaudio_get_Balance
 899 };