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 "quartz_private.h"
  22
  23 #include "uuids.h"
  24 #include "vfwmsgs.h"
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "dshow.h"
  28 #include "evcode.h"
  29 #include "strmif.h"
  30 #include "dsound.h"
  31 #include "amaudio.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  36
  37 /* NOTE: buffer can still be filled completely,
  38  * but we start waiting until only this amount is buffered
  39  */
  40 static const REFERENCE_TIME DSoundRenderer_Max_Fill = 150 * 10000;
  41
  42 struct dsound_render
  43 {
  44     struct strmbase_filter filter;
  45     struct strmbase_passthrough passthrough;
  46     IAMDirectSound IAMDirectSound_iface;
  47     IBasicAudio IBasicAudio_iface;
  48     IQualityControl IQualityControl_iface;
  49     IUnknown *system_clock;
  50
  51     struct strmbase_sink sink;
  52
  53     /* Signaled when the filter has completed a state change. The filter waits
  54      * for this event in IBaseFilter::GetState(). */
  55     HANDLE state_event;
  56     /* Signaled when a flush or state change occurs, i.e. anything that needs
  57      * to immediately unblock the streaming thread. */
  58     HANDLE flush_event;
  59     REFERENCE_TIME stream_start;
  60     BOOL eos;
  61
  62     IDirectSound8 *dsound;
  63     LPDIRECTSOUNDBUFFER dsbuffer;
  64     DWORD buf_size;
  65     DWORD last_playpos, writepos;
  66
  67     REFERENCE_TIME play_time;
  68
  69     LONG volume;
  70     LONG pan;
  71 };
  72
  73 static struct dsound_render *impl_from_strmbase_pin(struct strmbase_pin *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct dsound_render, sink.pin);
  76 }
  77
  78 static struct dsound_render *impl_from_strmbase_filter(struct strmbase_filter *iface)
  79 {
  80     return CONTAINING_RECORD(iface, struct dsound_render, filter);
  81 }
  82
  83 static struct dsound_render *impl_from_IBasicAudio(IBasicAudio *iface)
  84 {
  85     return CONTAINING_RECORD(iface, struct dsound_render, IBasicAudio_iface);
  86 }
  87
  88 static struct dsound_render *impl_from_IAMDirectSound(IAMDirectSound *iface)
  89 {
  90     return CONTAINING_RECORD(iface, struct dsound_render, IAMDirectSound_iface);
  91 }
  92
  93 static REFERENCE_TIME time_from_pos(struct dsound_render *This, DWORD pos)
  94 {
  95     WAVEFORMATEX *wfx = (WAVEFORMATEX *)This->sink.pin.mt.pbFormat;
  96     REFERENCE_TIME ret = 10000000;
  97     ret = ret * pos / wfx->nAvgBytesPerSec;
  98     return ret;
  99 }
 100
 101 static DWORD pos_from_time(struct dsound_render *This, REFERENCE_TIME time)
 102 {
 103     WAVEFORMATEX *wfx = (WAVEFORMATEX *)This->sink.pin.mt.pbFormat;
 104     REFERENCE_TIME ret = time;
 105     ret *= wfx->nAvgBytesPerSec;
 106     ret /= 10000000;
 107     ret -= ret % wfx->nBlockAlign;
 108     return ret;
 109 }
 110
 111 static void DSoundRender_UpdatePositions(struct dsound_render *This, DWORD *seqwritepos, DWORD *minwritepos)
 112 {
 113     WAVEFORMATEX *wfx = (WAVEFORMATEX *)This->sink.pin.mt.pbFormat;
 114     BYTE *buf1, *buf2;
 115     DWORD size1, size2, playpos, writepos, old_writepos, old_playpos, adv;
 116     BOOL writepos_set = This->writepos < This->buf_size;
 117
 118     /* Update position and zero */
 119     old_writepos = This->writepos;
 120     old_playpos = This->last_playpos;
 121     if (old_writepos <= old_playpos)
 122         old_writepos += This->buf_size;
 123
 124     IDirectSoundBuffer_GetCurrentPosition(This->dsbuffer, &playpos, &writepos);
 125     if (old_playpos > playpos) {
 126         adv = This->buf_size + playpos - old_playpos;
 127         This->play_time += time_from_pos(This, This->buf_size);
 128     } else
 129         adv = playpos - old_playpos;
 130     This->last_playpos = playpos;
 131     if (adv) {
 132         TRACE("Moving from %u to %u: clearing %u bytes\n", old_playpos, playpos, adv);
 133         IDirectSoundBuffer_Lock(This->dsbuffer, old_playpos, adv, (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
 134         memset(buf1, wfx->wBitsPerSample == 8 ? 128  : 0, size1);
 135         memset(buf2, wfx->wBitsPerSample == 8 ? 128  : 0, size2);
 136         IDirectSoundBuffer_Unlock(This->dsbuffer, buf1, size1, buf2, size2);
 137     }
 138     *minwritepos = writepos;
 139     if (!writepos_set || old_writepos < writepos) {
 140         if (writepos_set) {
 141             This->writepos = This->buf_size;
 142             FIXME("Underrun of data occurred!\n");
 143         }
 144         *seqwritepos = writepos;
 145     } else
 146         *seqwritepos = This->writepos;
 147 }
 148
 149 static HRESULT DSoundRender_GetWritePos(struct dsound_render *This,
 150         DWORD *ret_writepos, REFERENCE_TIME write_at, DWORD *pfree, DWORD *skip)
 151 {
 152     DWORD writepos, min_writepos, playpos;
 153     REFERENCE_TIME max_lag = 50 * 10000;
 154     REFERENCE_TIME cur, writepos_t, delta_t;
 155
 156     DSoundRender_UpdatePositions(This, &writepos, &min_writepos);
 157     playpos = This->last_playpos;
 158     if (This->filter.clock)
 159     {
 160         IReferenceClock_GetTime(This->filter.clock, &cur);
 161         cur -= This->stream_start;
 162     } else
 163         write_at = -1;
 164
 165     if (writepos == min_writepos)
 166         max_lag = 0;
 167
 168     *skip = 0;
 169     if (write_at < 0) {
 170         *ret_writepos = writepos;
 171         goto end;
 172     }
 173
 174     if (writepos >= playpos)
 175         writepos_t = cur + time_from_pos(This, writepos - playpos);
 176     else
 177         writepos_t = cur + time_from_pos(This, This->buf_size + writepos - playpos);
 178
 179     /* write_at: Starting time of sample */
 180     /* cur: current time of play position */
 181     /* writepos_t: current time of our pointer play position */
 182     delta_t = write_at - writepos_t;
 183     if (delta_t >= -max_lag && delta_t <= max_lag) {
 184         TRACE("Continuing from old position\n");
 185         *ret_writepos = writepos;
 186     } else if (delta_t < 0) {
 187         REFERENCE_TIME past, min_writepos_t;
 188         WARN("Delta too big %s/%s, overwriting old data or even skipping\n", debugstr_time(delta_t), debugstr_time(max_lag));
 189         if (min_writepos >= playpos)
 190             min_writepos_t = cur + time_from_pos(This, min_writepos - playpos);
 191         else
 192             min_writepos_t = cur + time_from_pos(This, This->buf_size - playpos + min_writepos);
 193         past = min_writepos_t - write_at;
 194         if (past >= 0) {
 195             DWORD skipbytes = pos_from_time(This, past);
 196             WARN("Skipping %u bytes\n", skipbytes);
 197             *skip = skipbytes;
 198             *ret_writepos = min_writepos;
 199         } else {
 200             DWORD aheadbytes = pos_from_time(This, -past);
 201             WARN("Advancing %u bytes\n", aheadbytes);
 202             *ret_writepos = (min_writepos + aheadbytes) % This->buf_size;
 203         }
 204     } else /* delta_t > 0 */ {
 205         DWORD aheadbytes;
 206         WARN("Delta too big %s/%s, too far ahead\n", debugstr_time(delta_t), debugstr_time(max_lag));
 207         aheadbytes = pos_from_time(This, delta_t);
 208         WARN("Advancing %u bytes\n", aheadbytes);
 209         if (delta_t >= DSoundRenderer_Max_Fill)
 210             return S_FALSE;
 211         *ret_writepos = (min_writepos + aheadbytes) % This->buf_size;
 212     }
 213 end:
 214     if (playpos >= *ret_writepos)
 215         *pfree = playpos - *ret_writepos;
 216     else
 217         *pfree = This->buf_size + playpos - *ret_writepos;
 218     if (time_from_pos(This, This->buf_size - *pfree) >= DSoundRenderer_Max_Fill) {
 219         TRACE("Blocked: too full %s / %s\n", debugstr_time(time_from_pos(This, This->buf_size - *pfree)),
 220                 debugstr_time(DSoundRenderer_Max_Fill));
 221         return S_FALSE;
 222     }
 223     return S_OK;
 224 }
 225
 226 static HRESULT DSoundRender_HandleEndOfStream(struct dsound_render *This)
 227 {
 228     while (This->filter.state == State_Running)
 229     {
 230         DWORD pos1, pos2;
 231         DSoundRender_UpdatePositions(This, &pos1, &pos2);
 232         if (pos1 == pos2)
 233             break;
 234
 235         WaitForSingleObject(This->flush_event, 10);
 236     }
 237
 238     return S_OK;
 239 }
 240
 241 static HRESULT DSoundRender_SendSampleData(struct dsound_render *This,
 242         REFERENCE_TIME tStart, REFERENCE_TIME tStop, const BYTE *data, DWORD size)
 243 {
 244     HRESULT hr;
 245
 246     while (size && This->filter.state != State_Stopped) {
 247         DWORD writepos, skip = 0, free, size1, size2, ret;
 248         BYTE *buf1, *buf2;
 249
 250         if (This->filter.state == State_Running)
 251             hr = DSoundRender_GetWritePos(This, &writepos, tStart, &free, &skip);
 252         else
 253             hr = S_FALSE;
 254
 255         if (hr != S_OK) {
 256             ret = WaitForSingleObject(This->flush_event, 10);
 257             if (This->sink.flushing || This->filter.state == State_Stopped)
 258                 return This->filter.state == State_Paused ? S_OK : VFW_E_WRONG_STATE;
 259             if (ret != WAIT_TIMEOUT)
 260                 ERR("%x\n", ret);
 261             continue;
 262         }
 263         tStart = -1;
 264
 265         if (skip)
 266             FIXME("Sample dropped %u of %u bytes\n", skip, size);
 267         if (skip >= size)
 268             return S_OK;
 269         data += skip;
 270         size -= skip;
 271
 272         hr = IDirectSoundBuffer_Lock(This->dsbuffer, writepos, min(free, size), (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
 273         if (hr != DS_OK) {
 274             ERR("Unable to lock sound buffer! (%x)\n", hr);
 275             break;
 276         }
 277         memcpy(buf1, data, size1);
 278         if (size2)
 279             memcpy(buf2, data+size1, size2);
 280         IDirectSoundBuffer_Unlock(This->dsbuffer, buf1, size1, buf2, size2);
 281         This->writepos = (writepos + size1 + size2) % This->buf_size;
 282         TRACE("Wrote %u bytes at %u, next at %u - (%u/%u)\n", size1+size2, writepos, This->writepos, free, size);
 283         data += size1 + size2;
 284         size -= size1 + size2;
 285     }
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI DSoundRender_PrepareReceive(struct dsound_render *This, IMediaSample *pSample)
 290 {
 291     HRESULT hr;
 292     AM_MEDIA_TYPE *amt;
 293
 294     if (IMediaSample_GetMediaType(pSample, &amt) == S_OK)
 295     {
 296         AM_MEDIA_TYPE *orig = &This->sink.pin.mt;
 297         WAVEFORMATEX *origfmt = (WAVEFORMATEX *)orig->pbFormat;
 298         WAVEFORMATEX *newfmt = (WAVEFORMATEX *)amt->pbFormat;
 299
 300         TRACE("Format change.\n");
 301         strmbase_dump_media_type(amt);
 302
 303         if (origfmt->wFormatTag == newfmt->wFormatTag &&
 304             origfmt->nChannels == newfmt->nChannels &&
 305             origfmt->nBlockAlign == newfmt->nBlockAlign &&
 306             origfmt->wBitsPerSample == newfmt->wBitsPerSample &&
 307             origfmt->cbSize ==  newfmt->cbSize)
 308         {
 309             if (origfmt->nSamplesPerSec != newfmt->nSamplesPerSec)
 310             {
 311                 hr = IDirectSoundBuffer_SetFrequency(This->dsbuffer,
 312                                                      newfmt->nSamplesPerSec);
 313                 if (FAILED(hr))
 314                     return VFW_E_TYPE_NOT_ACCEPTED;
 315                 FreeMediaType(orig);
 316                 CopyMediaType(orig, amt);
 317                 IMediaSample_SetMediaType(pSample, NULL);
 318             }
 319         }
 320         else
 321             return VFW_E_TYPE_NOT_ACCEPTED;
 322     }
 323     return S_OK;
 324 }
 325
 326 static HRESULT WINAPI DSoundRender_DoRenderSample(struct dsound_render *This, IMediaSample *pSample)
 327 {
 328     LPBYTE pbSrcStream = NULL;
 329     LONG cbSrcStream = 0;
 330     REFERENCE_TIME tStart, tStop;
 331     HRESULT hr;
 332
 333     hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
 334     if (FAILED(hr))
 335     {
 336         ERR("Cannot get pointer to sample data (%x)\n", hr);
 337         return hr;
 338     }
 339
 340     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
 341     if (FAILED(hr)) {
 342         ERR("Cannot get sample time (%x)\n", hr);
 343         tStart = tStop = -1;
 344     }
 345
 346     if (IMediaSample_IsPreroll(pSample) == S_OK)
 347     {
 348         TRACE("Preroll!\n");
 349         return S_OK;
 350     }
 351
 352     cbSrcStream = IMediaSample_GetActualDataLength(pSample);
 353     TRACE("Sample data ptr = %p, size = %d\n", pbSrcStream, cbSrcStream);
 354
 355     return DSoundRender_SendSampleData(This, tStart, tStop, pbSrcStream, cbSrcStream);
 356 }
 357
 358 static HRESULT WINAPI dsound_render_sink_Receive(struct strmbase_sink *iface, IMediaSample *sample)
 359 {
 360     struct dsound_render *filter = impl_from_strmbase_pin(&iface->pin);
 361     REFERENCE_TIME start, stop;
 362     HRESULT hr;
 363
 364     if (filter->eos || filter->sink.flushing)
 365         return S_FALSE;
 366
 367     if (filter->filter.state == State_Stopped)
 368         return VFW_E_WRONG_STATE;
 369
 370     if (FAILED(hr = DSoundRender_PrepareReceive(filter, sample)))
 371         return hr;
 372
 373     if (filter->filter.clock && SUCCEEDED(IMediaSample_GetTime(sample, &start, &stop)))
 374         strmbase_passthrough_update_time(&filter->passthrough, start);
 375
 376     if (filter->filter.state == State_Paused)
 377         SetEvent(filter->state_event);
 378
 379     return DSoundRender_DoRenderSample(filter, sample);
 380 }
 381
 382 static HRESULT dsound_render_sink_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
 383 {
 384     struct dsound_render *filter = impl_from_strmbase_pin(iface);
 385
 386     if (IsEqualGUID(iid, &IID_IMemInputPin))
 387         *out = &filter->sink.IMemInputPin_iface;
 388     else
 389         return E_NOINTERFACE;
 390
 391     IUnknown_AddRef((IUnknown *)*out);
 392     return S_OK;
 393 }
 394
 395 static HRESULT dsound_render_sink_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE * pmt)
 396 {
 397     if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Audio))
 398         return S_FALSE;
 399
 400     return S_OK;
 401 }
 402
 403 static HRESULT dsound_render_sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 404 {
 405     struct dsound_render *This = impl_from_strmbase_pin(&iface->pin);
 406     const WAVEFORMATEX *format = (WAVEFORMATEX *)mt->pbFormat;
 407     HRESULT hr = S_OK;
 408     DSBUFFERDESC buf_desc;
 409
 410     This->buf_size = format->nAvgBytesPerSec;
 411
 412     memset(&buf_desc,0,sizeof(DSBUFFERDESC));
 413     buf_desc.dwSize = sizeof(DSBUFFERDESC);
 414     buf_desc.dwFlags = DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN |
 415                        DSBCAPS_CTRLFREQUENCY | DSBCAPS_GLOBALFOCUS |
 416                        DSBCAPS_GETCURRENTPOSITION2;
 417     buf_desc.dwBufferBytes = This->buf_size;
 418     buf_desc.lpwfxFormat = (WAVEFORMATEX *)format;
 419     hr = IDirectSound8_CreateSoundBuffer(This->dsound, &buf_desc, &This->dsbuffer, NULL);
 420     This->writepos = This->buf_size;
 421     if (FAILED(hr))
 422         ERR("Can't create sound buffer (%x)\n", hr);
 423
 424     if (SUCCEEDED(hr))
 425     {
 426         hr = IDirectSoundBuffer_SetVolume(This->dsbuffer, This->volume);
 427         if (FAILED(hr))
 428             ERR("Can't set volume to %d (%x)\n", This->volume, hr);
 429
 430         hr = IDirectSoundBuffer_SetPan(This->dsbuffer, This->pan);
 431         if (FAILED(hr))
 432             ERR("Can't set pan to %d (%x)\n", This->pan, hr);
 433         hr = S_OK;
 434     }
 435
 436     if (FAILED(hr) && hr != VFW_E_ALREADY_CONNECTED)
 437     {
 438         if (This->dsbuffer)
 439             IDirectSoundBuffer_Release(This->dsbuffer);
 440         This->dsbuffer = NULL;
 441     }
 442
 443     return hr;
 444 }
 445
 446 static void dsound_render_sink_disconnect(struct strmbase_sink *iface)
 447 {
 448     struct dsound_render *This = impl_from_strmbase_pin(&iface->pin);
 449
 450     TRACE("(%p)->()\n", iface);
 451
 452     if (This->dsbuffer)
 453         IDirectSoundBuffer_Release(This->dsbuffer);
 454     This->dsbuffer = NULL;
 455 }
 456
 457 static HRESULT dsound_render_sink_eos(struct strmbase_sink *iface)
 458 {
 459     struct dsound_render *filter = impl_from_strmbase_pin(&iface->pin);
 460     IFilterGraph *graph = filter->filter.graph;
 461     IMediaEventSink *event_sink;
 462     void *buffer;
 463     DWORD size;
 464
 465     filter->eos = TRUE;
 466
 467     if (graph && SUCCEEDED(IFilterGraph_QueryInterface(graph,
 468             &IID_IMediaEventSink, (void **)&event_sink)))
 469     {
 470         IMediaEventSink_Notify(event_sink, EC_COMPLETE, S_OK,
 471                 (LONG_PTR)&filter->filter.IBaseFilter_iface);
 472         IMediaEventSink_Release(event_sink);
 473     }
 474     strmbase_passthrough_eos(&filter->passthrough);
 475     SetEvent(filter->state_event);
 476
 477     DSoundRender_HandleEndOfStream(filter);
 478
 479     IDirectSoundBuffer_Lock(filter->dsbuffer, 0, 0, &buffer, &size, NULL, NULL, DSBLOCK_ENTIREBUFFER);
 480     memset(buffer, 0, size);
 481     IDirectSoundBuffer_Unlock(filter->dsbuffer, buffer, size, NULL, 0);
 482
 483     return S_OK;
 484 }
 485
 486 static HRESULT dsound_render_sink_begin_flush(struct strmbase_sink *iface)
 487 {
 488     struct dsound_render *filter = impl_from_strmbase_pin(&iface->pin);
 489
 490     SetEvent(filter->flush_event);
 491     return S_OK;
 492 }
 493
 494 static HRESULT dsound_render_sink_end_flush(struct strmbase_sink *iface)
 495 {
 496     struct dsound_render *filter = impl_from_strmbase_pin(&iface->pin);
 497
 498     EnterCriticalSection(&filter->filter.stream_cs);
 499
 500     filter->eos = FALSE;
 501     strmbase_passthrough_invalidate_time(&filter->passthrough);
 502     ResetEvent(filter->flush_event);
 503
 504     if (filter->dsbuffer)
 505     {
 506         void *buffer;
 507         DWORD size;
 508
 509         /* Force a reset */
 510         IDirectSoundBuffer_Lock(filter->dsbuffer, 0, 0, &buffer, &size, NULL, NULL, DSBLOCK_ENTIREBUFFER);
 511         memset(buffer, 0, size);
 512         IDirectSoundBuffer_Unlock(filter->dsbuffer, buffer, size, NULL, 0);
 513         filter->writepos = filter->buf_size;
 514     }
 515
 516     LeaveCriticalSection(&filter->filter.stream_cs);
 517     return S_OK;
 518 }
 519
 520 static const struct strmbase_sink_ops sink_ops =
 521 {
 522     .base.pin_query_interface = dsound_render_sink_query_interface,
 523     .base.pin_query_accept = dsound_render_sink_query_accept,
 524     .pfnReceive = dsound_render_sink_Receive,
 525     .sink_connect = dsound_render_sink_connect,
 526     .sink_disconnect = dsound_render_sink_disconnect,
 527     .sink_eos = dsound_render_sink_eos,
 528     .sink_begin_flush = dsound_render_sink_begin_flush,
 529     .sink_end_flush = dsound_render_sink_end_flush,
 530 };
 531
 532 static void dsound_render_destroy(struct strmbase_filter *iface)
 533 {
 534     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 535
 536     if (filter->dsbuffer)
 537         IDirectSoundBuffer_Release(filter->dsbuffer);
 538     filter->dsbuffer = NULL;
 539     if (filter->dsound)
 540         IDirectSound8_Release(filter->dsound);
 541     filter->dsound = NULL;
 542
 543     if (filter->sink.pin.peer)
 544         IPin_Disconnect(filter->sink.pin.peer);
 545     IPin_Disconnect(&filter->sink.pin.IPin_iface);
 546     strmbase_sink_cleanup(&filter->sink);
 547
 548     CloseHandle(filter->state_event);
 549     CloseHandle(filter->flush_event);
 550
 551     strmbase_passthrough_cleanup(&filter->passthrough);
 552     strmbase_filter_cleanup(&filter->filter);
 553     free(filter);
 554
 555     InterlockedDecrement(&object_locks);
 556 }
 557
 558 static struct strmbase_pin *dsound_render_get_pin(struct strmbase_filter *iface, unsigned int index)
 559 {
 560     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 561
 562     if (index == 0)
 563         return &filter->sink.pin;
 564     return NULL;
 565 }
 566
 567 static HRESULT dsound_render_query_interface(struct strmbase_filter *iface, REFIID iid, void **out)
 568 {
 569     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 570
 571     if (IsEqualGUID(iid, &IID_IAMDirectSound))
 572         *out = &filter->IAMDirectSound_iface;
 573     else if (IsEqualGUID(iid, &IID_IBasicAudio))
 574         *out = &filter->IBasicAudio_iface;
 575     else if (IsEqualGUID(iid, &IID_IMediaPosition))
 576         *out = &filter->passthrough.IMediaPosition_iface;
 577     else if (IsEqualGUID(iid, &IID_IMediaSeeking))
 578         *out = &filter->passthrough.IMediaSeeking_iface;
 579     else if (IsEqualGUID(iid, &IID_IQualityControl))
 580         *out = &filter->IQualityControl_iface;
 581     else if (IsEqualGUID(iid, &IID_IReferenceClock))
 582         return IUnknown_QueryInterface(filter->system_clock, iid, out);
 583     else
 584         return E_NOINTERFACE;
 585
 586     IUnknown_AddRef((IUnknown *)*out);
 587     return S_OK;
 588 }
 589
 590 static HRESULT dsound_render_init_stream(struct strmbase_filter *iface)
 591 {
 592     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 593
 594     if (filter->sink.pin.peer)
 595         ResetEvent(filter->state_event);
 596     filter->eos = FALSE;
 597     ResetEvent(filter->flush_event);
 598
 599     return filter->sink.pin.peer ? S_FALSE : S_OK;
 600 }
 601
 602 static HRESULT dsound_render_start_stream(struct strmbase_filter *iface, REFERENCE_TIME start)
 603 {
 604     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 605
 606     filter->stream_start = start;
 607
 608     SetEvent(filter->state_event);
 609
 610     if (filter->sink.pin.peer)
 611     {
 612         filter->eos = FALSE;
 613         IDirectSoundBuffer_Play(filter->dsbuffer, 0, 0, DSBPLAY_LOOPING);
 614     }
 615
 616     return S_OK;
 617 }
 618
 619 static HRESULT dsound_render_stop_stream(struct strmbase_filter *iface)
 620 {
 621     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 622
 623     if (filter->sink.pin.peer)
 624     {
 625         IDirectSoundBuffer_Stop(filter->dsbuffer);
 626         filter->writepos = filter->buf_size;
 627     }
 628     return S_OK;
 629 }
 630
 631 static HRESULT dsound_render_cleanup_stream(struct strmbase_filter *iface)
 632 {
 633     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 634
 635     strmbase_passthrough_invalidate_time(&filter->passthrough);
 636     SetEvent(filter->state_event);
 637     SetEvent(filter->flush_event);
 638
 639     return S_OK;
 640 }
 641
 642 static HRESULT dsound_render_wait_state(struct strmbase_filter *iface, DWORD timeout)
 643 {
 644     struct dsound_render *filter = impl_from_strmbase_filter(iface);
 645
 646     if (WaitForSingleObject(filter->state_event, timeout) == WAIT_TIMEOUT)
 647         return VFW_S_STATE_INTERMEDIATE;
 648     return S_OK;
 649 }
 650
 651 static const struct strmbase_filter_ops filter_ops =
 652 {
 653     .filter_destroy = dsound_render_destroy,
 654     .filter_get_pin = dsound_render_get_pin,
 655     .filter_query_interface = dsound_render_query_interface,
 656     .filter_init_stream = dsound_render_init_stream,
 657     .filter_start_stream = dsound_render_start_stream,
 658     .filter_stop_stream = dsound_render_stop_stream,
 659     .filter_cleanup_stream = dsound_render_cleanup_stream,
 660     .filter_wait_state = dsound_render_wait_state,
 661 };
 662
 663 /*** IUnknown methods ***/
 664 static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface,
 665                                                 REFIID riid,
 666                                                 LPVOID*ppvObj) {
 667     struct dsound_render *This = impl_from_IBasicAudio(iface);
 668
 669     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
 670
 671     return IUnknown_QueryInterface(This->filter.outer_unk, riid, ppvObj);
 672 }
 673
 674 static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) {
 675     struct dsound_render *This = impl_from_IBasicAudio(iface);
 676
 677     TRACE("(%p/%p)->()\n", This, iface);
 678
 679     return IUnknown_AddRef(This->filter.outer_unk);
 680 }
 681
 682 static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) {
 683     struct dsound_render *This = impl_from_IBasicAudio(iface);
 684
 685     TRACE("(%p/%p)->()\n", This, iface);
 686
 687     return IUnknown_Release(This->filter.outer_unk);
 688 }
 689
 690 HRESULT WINAPI basic_audio_GetTypeInfoCount(IBasicAudio *iface, UINT *count)
 691 {
 692     TRACE("iface %p, count %p.\n", iface, count);
 693     *count = 1;
 694     return S_OK;
 695 }
 696
 697 HRESULT WINAPI basic_audio_GetTypeInfo(IBasicAudio *iface, UINT index,
 698         LCID lcid, ITypeInfo **typeinfo)
 699 {
 700     TRACE("iface %p, index %u, lcid %#x, typeinfo %p.\n", iface, index, lcid, typeinfo);
 701     return strmbase_get_typeinfo(IBasicAudio_tid, typeinfo);
 702 }
 703
 704 HRESULT WINAPI basic_audio_GetIDsOfNames(IBasicAudio *iface, REFIID iid,
 705         LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 706 {
 707     ITypeInfo *typeinfo;
 708     HRESULT hr;
 709
 710     TRACE("iface %p, iid %s, names %p, count %u, lcid %#x, ids %p.\n",
 711             iface, debugstr_guid(iid), names, count, lcid, ids);
 712
 713     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicAudio_tid, &typeinfo)))
 714     {
 715         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
 716         ITypeInfo_Release(typeinfo);
 717     }
 718     return hr;
 719 }
 720
 721 static HRESULT WINAPI basic_audio_Invoke(IBasicAudio *iface, DISPID id, REFIID iid, LCID lcid,
 722         WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 723 {
 724     ITypeInfo *typeinfo;
 725     HRESULT hr;
 726
 727     TRACE("iface %p, id %d, iid %s, lcid %#x, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
 728             iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
 729
 730     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicAudio_tid, &typeinfo)))
 731     {
 732         hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
 733         ITypeInfo_Release(typeinfo);
 734     }
 735     return hr;
 736 }
 737
 738 static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface,
 739                                             LONG lVolume) {
 740     struct dsound_render *This = impl_from_IBasicAudio(iface);
 741
 742     TRACE("(%p/%p)->(%d)\n", This, iface, lVolume);
 743
 744     if (lVolume > DSBVOLUME_MAX || lVolume < DSBVOLUME_MIN)
 745         return E_INVALIDARG;
 746
 747     if (This->dsbuffer) {
 748         if (FAILED(IDirectSoundBuffer_SetVolume(This->dsbuffer, lVolume)))
 749             return E_FAIL;
 750     }
 751
 752     This->volume = lVolume;
 753     return S_OK;
 754 }
 755
 756 static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface,
 757                                             LONG *plVolume) {
 758     struct dsound_render *This = impl_from_IBasicAudio(iface);
 759
 760     TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
 761
 762     if (!plVolume)
 763         return E_POINTER;
 764
 765     *plVolume = This->volume;
 766     return S_OK;
 767 }
 768
 769 static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface,
 770                                              LONG lBalance) {
 771     struct dsound_render *This = impl_from_IBasicAudio(iface);
 772
 773     TRACE("(%p/%p)->(%d)\n", This, iface, lBalance);
 774
 775     if (lBalance < DSBPAN_LEFT || lBalance > DSBPAN_RIGHT)
 776         return E_INVALIDARG;
 777
 778     if (This->dsbuffer) {
 779         if (FAILED(IDirectSoundBuffer_SetPan(This->dsbuffer, lBalance)))
 780             return E_FAIL;
 781     }
 782
 783     This->pan = lBalance;
 784     return S_OK;
 785 }
 786
 787 static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface,
 788                                              LONG *plBalance) {
 789     struct dsound_render *This = impl_from_IBasicAudio(iface);
 790
 791     TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
 792
 793     if (!plBalance)
 794         return E_POINTER;
 795
 796     *plBalance = This->pan;
 797     return S_OK;
 798 }
 799
 800 static const IBasicAudioVtbl IBasicAudio_Vtbl =
 801 {
 802     Basicaudio_QueryInterface,
 803     Basicaudio_AddRef,
 804     Basicaudio_Release,
 805     basic_audio_GetTypeInfoCount,
 806     basic_audio_GetTypeInfo,
 807     basic_audio_GetIDsOfNames,
 808     basic_audio_Invoke,
 809     Basicaudio_put_Volume,
 810     Basicaudio_get_Volume,
 811     Basicaudio_put_Balance,
 812     Basicaudio_get_Balance
 813 };
 814
 815 /*** IUnknown methods ***/
 816 static HRESULT WINAPI AMDirectSound_QueryInterface(IAMDirectSound *iface,
 817                                                 REFIID riid,
 818                                                 LPVOID*ppvObj)
 819 {
 820     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 821
 822     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
 823
 824     return IUnknown_QueryInterface(This->filter.outer_unk, riid, ppvObj);
 825 }
 826
 827 static ULONG WINAPI AMDirectSound_AddRef(IAMDirectSound *iface)
 828 {
 829     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 830
 831     TRACE("(%p/%p)->()\n", This, iface);
 832
 833     return IUnknown_AddRef(This->filter.outer_unk);
 834 }
 835
 836 static ULONG WINAPI AMDirectSound_Release(IAMDirectSound *iface)
 837 {
 838     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 839
 840     TRACE("(%p/%p)->()\n", This, iface);
 841
 842     return IUnknown_Release(This->filter.outer_unk);
 843 }
 844
 845 /*** IAMDirectSound methods ***/
 846 static HRESULT WINAPI AMDirectSound_GetDirectSoundInterface(IAMDirectSound *iface,  IDirectSound **ds)
 847 {
 848     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 849
 850     FIXME("(%p/%p)->(%p): stub\n", This, iface, ds);
 851
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI AMDirectSound_GetPrimaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer **buf)
 856 {
 857     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 858
 859     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
 860
 861     return E_NOTIMPL;
 862 }
 863
 864 static HRESULT WINAPI AMDirectSound_GetSecondaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer **buf)
 865 {
 866     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 867
 868     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
 869
 870     return E_NOTIMPL;
 871 }
 872
 873 static HRESULT WINAPI AMDirectSound_ReleaseDirectSoundInterface(IAMDirectSound *iface, IDirectSound *ds)
 874 {
 875     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 876
 877     FIXME("(%p/%p)->(%p): stub\n", This, iface, ds);
 878
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI AMDirectSound_ReleasePrimaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer *buf)
 883 {
 884     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 885
 886     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
 887
 888     return E_NOTIMPL;
 889 }
 890
 891 static HRESULT WINAPI AMDirectSound_ReleaseSecondaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer *buf)
 892 {
 893     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 894
 895     FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
 896
 897     return E_NOTIMPL;
 898 }
 899
 900 static HRESULT WINAPI AMDirectSound_SetFocusWindow(IAMDirectSound *iface, HWND hwnd, BOOL bgaudible)
 901 {
 902     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 903
 904     FIXME("(%p/%p)->(%p,%d): stub\n", This, iface, hwnd, bgaudible);
 905
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI AMDirectSound_GetFocusWindow(IAMDirectSound *iface, HWND *hwnd, BOOL *bgaudible)
 910 {
 911     struct dsound_render *This = impl_from_IAMDirectSound(iface);
 912
 913     FIXME("(%p/%p)->(%p,%p): stub\n", This, iface, hwnd, bgaudible);
 914
 915     return E_NOTIMPL;
 916 }
 917
 918 static const IAMDirectSoundVtbl IAMDirectSound_Vtbl =
 919 {
 920     AMDirectSound_QueryInterface,
 921     AMDirectSound_AddRef,
 922     AMDirectSound_Release,
 923     AMDirectSound_GetDirectSoundInterface,
 924     AMDirectSound_GetPrimaryBufferInterface,
 925     AMDirectSound_GetSecondaryBufferInterface,
 926     AMDirectSound_ReleaseDirectSoundInterface,
 927     AMDirectSound_ReleasePrimaryBufferInterface,
 928     AMDirectSound_ReleaseSecondaryBufferInterface,
 929     AMDirectSound_SetFocusWindow,
 930     AMDirectSound_GetFocusWindow
 931 };
 932
 933 static struct dsound_render *impl_from_IQualityControl(IQualityControl *iface)
 934 {
 935     return CONTAINING_RECORD(iface, struct dsound_render, IQualityControl_iface);
 936 }
 937
 938 static HRESULT WINAPI dsound_render_qc_QueryInterface(IQualityControl *iface,
 939         REFIID iid, void **out)
 940 {
 941     struct dsound_render *filter = impl_from_IQualityControl(iface);
 942     return IUnknown_QueryInterface(filter->filter.outer_unk, iid, out);
 943 }
 944
 945 static ULONG WINAPI dsound_render_qc_AddRef(IQualityControl *iface)
 946 {
 947     struct dsound_render *filter = impl_from_IQualityControl(iface);
 948     return IUnknown_AddRef(filter->filter.outer_unk);
 949 }
 950
 951 static ULONG WINAPI dsound_render_qc_Release(IQualityControl *iface)
 952 {
 953     struct dsound_render *filter = impl_from_IQualityControl(iface);
 954     return IUnknown_AddRef(filter->filter.outer_unk);
 955 }
 956
 957 static HRESULT WINAPI dsound_render_qc_Notify(IQualityControl *iface,
 958         IBaseFilter *sender, Quality q)
 959 {
 960     struct dsound_render *filter = impl_from_IQualityControl(iface);
 961
 962     FIXME("filter %p, sender %p, type %#x, proportion %u, late %s, timestamp %s, stub!\n",
 963             filter, sender, q.Type, q.Proportion, debugstr_time(q.Late), debugstr_time(q.TimeStamp));
 964
 965     return E_NOTIMPL;
 966 }
 967
 968 static HRESULT WINAPI dsound_render_qc_SetSink(IQualityControl *iface, IQualityControl *sink)
 969 {
 970     struct dsound_render *filter = impl_from_IQualityControl(iface);
 971
 972     FIXME("filter %p, sink %p, stub!\n", filter, sink);
 973
 974     return E_NOTIMPL;
 975 }
 976
 977 static const IQualityControlVtbl dsound_render_qc_vtbl =
 978 {
 979     dsound_render_qc_QueryInterface,
 980     dsound_render_qc_AddRef,
 981     dsound_render_qc_Release,
 982     dsound_render_qc_Notify,
 983     dsound_render_qc_SetSink,
 984 };
 985
 986 HRESULT dsound_render_create(IUnknown *outer, IUnknown **out)
 987 {
 988     static const DSBUFFERDESC buffer_desc = {
 989         .dwSize = sizeof(DSBUFFERDESC),
 990         .dwFlags = DSBCAPS_PRIMARYBUFFER,
 991     };
 992
 993     struct dsound_render *object;
 994     IDirectSoundBuffer *buffer;
 995     HRESULT hr;
 996
 997     if (!(object = calloc(1, sizeof(*object))))
 998         return E_OUTOFMEMORY;
 999
1000     strmbase_filter_init(&object->filter, outer, &CLSID_DSoundRender, &filter_ops);
1001
1002     if (FAILED(hr = system_clock_create(&object->filter.IUnknown_inner, &object->system_clock)))
1003     {
1004         strmbase_filter_cleanup(&object->filter);
1005         free(object);
1006         return hr;
1007     }
1008
1009     if (FAILED(hr = DirectSoundCreate8(NULL, &object->dsound, NULL)))
1010     {
1011         IUnknown_Release(object->system_clock);
1012         strmbase_filter_cleanup(&object->filter);
1013         free(object);
1014         return hr;
1015     }
1016
1017     if (FAILED(hr = IDirectSound8_SetCooperativeLevel(object->dsound,
1018             GetDesktopWindow(), DSSCL_PRIORITY)))
1019     {
1020         IDirectSound8_Release(object->dsound);
1021         IUnknown_Release(object->system_clock);
1022         strmbase_filter_cleanup(&object->filter);
1023         free(object);
1024         return hr;
1025     }
1026
1027     if (SUCCEEDED(hr = IDirectSound8_CreateSoundBuffer(object->dsound,
1028             &buffer_desc, &buffer, NULL)))
1029     {
1030         IDirectSoundBuffer_Play(buffer, 0, 0, DSBPLAY_LOOPING);
1031         IDirectSoundBuffer_Release(buffer);
1032     }
1033
1034     strmbase_passthrough_init(&object->passthrough, (IUnknown *)&object->filter.IBaseFilter_iface);
1035     ISeekingPassThru_Init(&object->passthrough.ISeekingPassThru_iface, TRUE, &object->sink.pin.IPin_iface);
1036
1037     strmbase_sink_init(&object->sink, &object->filter, L"Audio Input pin (rendered)", &sink_ops, NULL);
1038
1039     object->state_event = CreateEventW(NULL, TRUE, TRUE, NULL);
1040     object->flush_event = CreateEventW(NULL, TRUE, TRUE, NULL);
1041
1042     object->IBasicAudio_iface.lpVtbl = &IBasicAudio_Vtbl;
1043     object->IAMDirectSound_iface.lpVtbl = &IAMDirectSound_Vtbl;
1044     object->IQualityControl_iface.lpVtbl = &dsound_render_qc_vtbl;
1045
1046     TRACE("Created DirectSound renderer %p.\n", object);
1047     *out = &object->filter.IUnknown_inner;
1048
1049     return S_OK;
1050 }