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