dlls/dsdmo/main.c

   1 /*
   2  * Copyright 2019 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #include "dmo.h"
  21 #include "mmreg.h"
  22 #include "mmsystem.h"
  23 #include "uuids.h"
  24 #include "initguid.h"
  25 #include "dsound.h"
  26 #include "rpcproxy.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(dsdmo);
  31
  32 static HINSTANCE dsdmo_instance;
  33
  34 struct effect
  35 {
  36     IMediaObject IMediaObject_iface;
  37     IMediaObjectInPlace IMediaObjectInPlace_iface;
  38     IUnknown IUnknown_inner;
  39     IUnknown *outer_unk;
  40     LONG refcount;
  41
  42     CRITICAL_SECTION cs;
  43     WAVEFORMATEX format;
  44
  45     const struct effect_ops *ops;
  46 };
  47
  48 struct effect_ops
  49 {
  50     void *(*query_interface)(struct effect *effect, REFIID iid);
  51     void (*destroy)(struct effect *effect);
  52 };
  53
  54 static struct effect *impl_from_IUnknown(IUnknown *iface)
  55 {
  56     return CONTAINING_RECORD(iface, struct effect, IUnknown_inner);
  57 }
  58
  59 static HRESULT WINAPI effect_inner_QueryInterface(IUnknown *iface, REFIID iid, void **out)
  60 {
  61     struct effect *effect = impl_from_IUnknown(iface);
  62
  63     TRACE("effect %p, iid %s, out %p.\n", effect, debugstr_guid(iid), out);
  64
  65     if (IsEqualGUID(iid, &IID_IUnknown))
  66         *out = iface;
  67     else if (IsEqualGUID(iid, &IID_IMediaObject))
  68         *out = &effect->IMediaObject_iface;
  69     else if (IsEqualGUID(iid, &IID_IMediaObjectInPlace))
  70         *out = &effect->IMediaObjectInPlace_iface;
  71     else if (!(*out = effect->ops->query_interface(effect, iid)))
  72     {
  73         WARN("%s not implemented; returning E_NOINTERFACE.\n", debugstr_guid(iid));
  74         return E_NOINTERFACE;
  75     }
  76
  77     IUnknown_AddRef((IUnknown *)*out);
  78     return S_OK;
  79 }
  80
  81 static ULONG WINAPI effect_inner_AddRef(IUnknown *iface)
  82 {
  83     struct effect *effect = impl_from_IUnknown(iface);
  84     ULONG refcount = InterlockedIncrement(&effect->refcount);
  85
  86     TRACE("%p increasing refcount to %u.\n", effect, refcount);
  87     return refcount;
  88 }
  89
  90 static ULONG WINAPI effect_inner_Release(IUnknown *iface)
  91 {
  92     struct effect *effect = impl_from_IUnknown(iface);
  93     ULONG refcount = InterlockedDecrement(&effect->refcount);
  94
  95     TRACE("%p decreasing refcount to %u.\n", effect, refcount);
  96
  97     if (!refcount)
  98     {
  99         effect->cs.DebugInfo->Spare[0] = 0;
 100         DeleteCriticalSection(&effect->cs);
 101         effect->ops->destroy(effect);
 102     }
 103     return refcount;
 104 }
 105
 106 static const IUnknownVtbl effect_inner_vtbl =
 107 {
 108     effect_inner_QueryInterface,
 109     effect_inner_AddRef,
 110     effect_inner_Release,
 111 };
 112
 113 static struct effect *impl_from_IMediaObject(IMediaObject *iface)
 114 {
 115     return CONTAINING_RECORD(iface, struct effect, IMediaObject_iface);
 116 }
 117
 118 static HRESULT WINAPI effect_QueryInterface(IMediaObject *iface, REFIID iid, void **out)
 119 {
 120     struct effect *effect = impl_from_IMediaObject(iface);
 121     return IUnknown_QueryInterface(effect->outer_unk, iid, out);
 122 }
 123
 124 static ULONG WINAPI effect_AddRef(IMediaObject *iface)
 125 {
 126     struct effect *effect = impl_from_IMediaObject(iface);
 127     return IUnknown_AddRef(effect->outer_unk);
 128 }
 129
 130 static ULONG WINAPI effect_Release(IMediaObject *iface)
 131 {
 132     struct effect *effect = impl_from_IMediaObject(iface);
 133     return IUnknown_Release(effect->outer_unk);
 134 }
 135
 136 static HRESULT WINAPI effect_GetStreamCount(IMediaObject *iface, DWORD *input, DWORD *output)
 137 {
 138     FIXME("iface %p, input %p, output %p, stub!\n", iface, input, output);
 139     return E_NOTIMPL;
 140 }
 141
 142 static HRESULT WINAPI effect_GetInputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
 143 {
 144     FIXME("iface %p, index %u, flags %p, stub!\n", iface, index, flags);
 145     return E_NOTIMPL;
 146 }
 147
 148 static HRESULT WINAPI effect_GetOutputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
 149 {
 150     FIXME("iface %p, index %u, flags %p, stub!\n", iface, index, flags);
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI effect_GetInputType(IMediaObject *iface, DWORD index, DWORD type_index, DMO_MEDIA_TYPE *type)
 155 {
 156     FIXME("iface %p, index %u, type_index %u, type %p, stub!\n", iface, index, type_index, type);
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI effect_GetOutputType(IMediaObject *iface, DWORD index, DWORD type_index, DMO_MEDIA_TYPE *type)
 161 {
 162     FIXME("iface %p, index %u, type_index %u, type %p, stub!\n", iface, index, type_index, type);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI effect_SetInputType(IMediaObject *iface, DWORD index, const DMO_MEDIA_TYPE *type, DWORD flags)
 167 {
 168     struct effect *effect = impl_from_IMediaObject(iface);
 169     const WAVEFORMATEX *format;
 170
 171     TRACE("iface %p, index %u, type %p, flags %#x.\n", iface, index, type, flags);
 172
 173     if (flags & DMO_SET_TYPEF_CLEAR)
 174     {
 175         EnterCriticalSection(&effect->cs);
 176         memset(&effect->format, 0, sizeof(effect->format));
 177         LeaveCriticalSection(&effect->cs);
 178         return S_OK;
 179     }
 180
 181     if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
 182         return DMO_E_TYPE_NOT_ACCEPTED;
 183
 184     if (!IsEqualGUID(&type->subtype, &MEDIASUBTYPE_PCM)
 185             && !IsEqualGUID(&type->subtype, &MEDIASUBTYPE_IEEE_FLOAT))
 186         return DMO_E_TYPE_NOT_ACCEPTED;
 187
 188     if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))
 189         return DMO_E_TYPE_NOT_ACCEPTED;
 190
 191     format = (const WAVEFORMATEX *)type->pbFormat;
 192     if (format->wFormatTag == WAVE_FORMAT_PCM)
 193     {
 194         if (format->wBitsPerSample != 8 && format->wBitsPerSample != 16)
 195         {
 196             WARN("Rejecting %u-bit integer PCM.\n", format->wBitsPerSample);
 197             return DMO_E_TYPE_NOT_ACCEPTED;
 198         }
 199     }
 200     else if (format->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 201     {
 202         if (format->wBitsPerSample != 32)
 203         {
 204             WARN("Rejecting %u-bit float PCM.\n", format->wBitsPerSample);
 205             return DMO_E_TYPE_NOT_ACCEPTED;
 206         }
 207     }
 208     else
 209     {
 210         WARN("Rejecting tag %#x.\n", format->wFormatTag);
 211         return DMO_E_TYPE_NOT_ACCEPTED;
 212     }
 213
 214     if (format->nChannels != 1 && format->nChannels != 2)
 215     {
 216         WARN("Rejecting %u channels.\n", format->nChannels);
 217         return DMO_E_TYPE_NOT_ACCEPTED;
 218     }
 219
 220     EnterCriticalSection(&effect->cs);
 221     effect->format = *format;
 222     LeaveCriticalSection(&effect->cs);
 223
 224     return S_OK;
 225 }
 226
 227 static HRESULT WINAPI effect_SetOutputType(IMediaObject *iface, DWORD index, const DMO_MEDIA_TYPE *type, DWORD flags)
 228 {
 229     struct effect *effect = impl_from_IMediaObject(iface);
 230     HRESULT hr;
 231
 232     TRACE("iface %p, index %u, type %p, flags %#x.\n", iface, index, type, flags);
 233
 234     if (flags & DMO_SET_TYPEF_CLEAR)
 235         return S_OK;
 236
 237     if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
 238         return DMO_E_TYPE_NOT_ACCEPTED;
 239
 240     if (!IsEqualGUID(&type->subtype, &MEDIASUBTYPE_PCM)
 241             && !IsEqualGUID(&type->subtype, &MEDIASUBTYPE_IEEE_FLOAT))
 242         return DMO_E_TYPE_NOT_ACCEPTED;
 243
 244     if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))
 245         return DMO_E_TYPE_NOT_ACCEPTED;
 246
 247     EnterCriticalSection(&effect->cs);
 248     hr = memcmp(type->pbFormat, &effect->format, sizeof(WAVEFORMATEX)) ? DMO_E_TYPE_NOT_ACCEPTED : S_OK;
 249     LeaveCriticalSection(&effect->cs);
 250
 251     return hr;
 252 }
 253
 254 static HRESULT WINAPI effect_GetInputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
 255 {
 256     FIXME("iface %p, index %u, type %p, stub!\n", iface, index, type);
 257     return E_NOTIMPL;
 258 }
 259
 260 static HRESULT WINAPI effect_GetOutputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
 261 {
 262     FIXME("iface %p, index %u, type %p, stub!\n", iface, index, type);
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI effect_GetInputSizeInfo(IMediaObject *iface, DWORD index,
 267         DWORD *size, DWORD *lookahead, DWORD *alignment)
 268 {
 269     FIXME("iface %p, index %u, size %p, lookahead %p, alignment %p, stub!\n", iface, index, size, lookahead, alignment);
 270     return E_NOTIMPL;
 271 }
 272
 273 static HRESULT WINAPI effect_GetOutputSizeInfo(IMediaObject *iface, DWORD index, DWORD *size, DWORD *alignment)
 274 {
 275     FIXME("iface %p, index %u, size %p, alignment %p, stub!\n", iface, index, size, alignment);
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI effect_GetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME *latency)
 280 {
 281     FIXME("iface %p, index %u, latency %p, stub!\n", iface, index, latency);
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI effect_SetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME latency)
 286 {
 287     FIXME("iface %p, index %u, latency %s, stub!\n", iface, index, wine_dbgstr_longlong(latency));
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI effect_Flush(IMediaObject *iface)
 292 {
 293     FIXME("iface %p, stub!\n", iface);
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI effect_Discontinuity(IMediaObject *iface, DWORD index)
 298 {
 299     FIXME("iface %p, index %u, stub!\n", iface, index);
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI effect_AllocateStreamingResources(IMediaObject *iface)
 304 {
 305     FIXME("iface %p, stub!\n", iface);
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI effect_FreeStreamingResources(IMediaObject *iface)
 310 {
 311     FIXME("iface %p, stub!\n", iface);
 312     return E_NOTIMPL;
 313 }
 314
 315 static HRESULT WINAPI effect_GetInputStatus(IMediaObject *iface, DWORD index, DWORD *flags)
 316 {
 317     FIXME("iface %p, index %u, flags %p, stub!\n", iface, index, flags);
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI effect_ProcessInput(IMediaObject *iface, DWORD index,
 322     IMediaBuffer *buffer, DWORD flags, REFERENCE_TIME timestamp, REFERENCE_TIME timelength)
 323 {
 324     FIXME("iface %p, index %u, buffer %p, flags %#x, timestamp %s, timelength %s, stub!\n",
 325             iface, index, buffer, flags, wine_dbgstr_longlong(timestamp), wine_dbgstr_longlong(timelength));
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI effect_ProcessOutput(IMediaObject *iface, DWORD flags,
 330         DWORD count, DMO_OUTPUT_DATA_BUFFER *buffers, DWORD *status)
 331 {
 332     FIXME("iface %p, flags %#x, count %u, buffers %p, status %p, stub!\n", iface, flags, count, buffers, status);
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI effect_Lock(IMediaObject *iface, LONG lock)
 337 {
 338     FIXME("iface %p, lock %d, stub!\n", iface, lock);
 339     return E_NOTIMPL;
 340 }
 341
 342 static const IMediaObjectVtbl effect_vtbl =
 343 {
 344     effect_QueryInterface,
 345     effect_AddRef,
 346     effect_Release,
 347     effect_GetStreamCount,
 348     effect_GetInputStreamInfo,
 349     effect_GetOutputStreamInfo,
 350     effect_GetInputType,
 351     effect_GetOutputType,
 352     effect_SetInputType,
 353     effect_SetOutputType,
 354     effect_GetInputCurrentType,
 355     effect_GetOutputCurrentType,
 356     effect_GetInputSizeInfo,
 357     effect_GetOutputSizeInfo,
 358     effect_GetInputMaxLatency,
 359     effect_SetInputMaxLatency,
 360     effect_Flush,
 361     effect_Discontinuity,
 362     effect_AllocateStreamingResources,
 363     effect_FreeStreamingResources,
 364     effect_GetInputStatus,
 365     effect_ProcessInput,
 366     effect_ProcessOutput,
 367     effect_Lock,
 368 };
 369
 370 static struct effect *impl_from_IMediaObjectInPlace(IMediaObjectInPlace *iface)
 371 {
 372     return CONTAINING_RECORD(iface, struct effect, IMediaObjectInPlace_iface);
 373 }
 374
 375 static HRESULT WINAPI effect_inplace_QueryInterface(IMediaObjectInPlace *iface, REFIID iid, void **out)
 376 {
 377     struct effect *effect = impl_from_IMediaObjectInPlace(iface);
 378     return IUnknown_QueryInterface(effect->outer_unk, iid, out);
 379 }
 380
 381 static ULONG WINAPI effect_inplace_AddRef(IMediaObjectInPlace *iface)
 382 {
 383     struct effect *effect = impl_from_IMediaObjectInPlace(iface);
 384     return IUnknown_AddRef(effect->outer_unk);
 385 }
 386
 387 static ULONG WINAPI effect_inplace_Release(IMediaObjectInPlace *iface)
 388 {
 389     struct effect *effect = impl_from_IMediaObjectInPlace(iface);
 390     return IUnknown_Release(effect->outer_unk);
 391 }
 392
 393 static HRESULT WINAPI effect_inplace_Process(IMediaObjectInPlace *iface, ULONG size,
 394         BYTE *data, REFERENCE_TIME start, DWORD flags)
 395 {
 396     FIXME("iface %p, size %u, data %p, start %s, flags %#x, stub!\n",
 397             iface, size, data, wine_dbgstr_longlong(start), flags);
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI effect_inplace_Clone(IMediaObjectInPlace *iface, IMediaObjectInPlace **out)
 402 {
 403     FIXME("iface %p, out %p, stub!\n", iface, out);
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI effect_inplace_GetLatency(IMediaObjectInPlace *iface, REFERENCE_TIME *latency)
 408 {
 409     FIXME("iface %p, latency %p, stub!\n", iface, latency);
 410     return E_NOTIMPL;
 411 }
 412
 413 static const IMediaObjectInPlaceVtbl effect_inplace_vtbl =
 414 {
 415     effect_inplace_QueryInterface,
 416     effect_inplace_AddRef,
 417     effect_inplace_Release,
 418     effect_inplace_Process,
 419     effect_inplace_Clone,
 420     effect_inplace_GetLatency,
 421 };
 422
 423 static void effect_init(struct effect *effect, IUnknown *outer, const struct effect_ops *ops)
 424 {
 425     effect->outer_unk = outer ? outer : &effect->IUnknown_inner;
 426     effect->refcount = 1;
 427     effect->IUnknown_inner.lpVtbl = &effect_inner_vtbl;
 428     effect->IMediaObject_iface.lpVtbl = &effect_vtbl;
 429     effect->IMediaObjectInPlace_iface.lpVtbl = &effect_inplace_vtbl;
 430
 431     InitializeCriticalSection(&effect->cs);
 432     effect->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": effect.cs");
 433
 434     effect->ops = ops;
 435 }
 436
 437 struct eq
 438 {
 439     struct effect effect;
 440     IDirectSoundFXParamEq IDirectSoundFXParamEq_iface;
 441     DSFXParamEq params;
 442 };
 443
 444 static struct eq *impl_from_IDirectSoundFXParamEq(IDirectSoundFXParamEq *iface)
 445 {
 446     return CONTAINING_RECORD(iface, struct eq, IDirectSoundFXParamEq_iface);
 447 }
 448
 449 static HRESULT WINAPI eq_params_QueryInterface(IDirectSoundFXParamEq *iface, REFIID iid, void **out)
 450 {
 451     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 452     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
 453 }
 454
 455 static ULONG WINAPI eq_params_AddRef(IDirectSoundFXParamEq *iface)
 456 {
 457     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 458     return IUnknown_AddRef(effect->effect.outer_unk);
 459 }
 460
 461 static ULONG WINAPI eq_params_Release(IDirectSoundFXParamEq *iface)
 462 {
 463     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 464     return IUnknown_Release(effect->effect.outer_unk);
 465 }
 466
 467 static HRESULT WINAPI eq_params_SetAllParameters(IDirectSoundFXParamEq *iface, const DSFXParamEq *params)
 468 {
 469     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 470
 471     TRACE("effect %p, params %p.\n", effect, params);
 472
 473     EnterCriticalSection(&effect->effect.cs);
 474     effect->params = *params;
 475     LeaveCriticalSection(&effect->effect.cs);
 476     return S_OK;
 477 }
 478
 479 static HRESULT WINAPI eq_params_GetAllParameters(IDirectSoundFXParamEq *iface, DSFXParamEq *params)
 480 {
 481     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 482
 483     TRACE("effect %p, params %p.\n", effect, params);
 484
 485     EnterCriticalSection(&effect->effect.cs);
 486     *params = effect->params;
 487     LeaveCriticalSection(&effect->effect.cs);
 488     return S_OK;
 489 }
 490
 491 static const IDirectSoundFXParamEqVtbl eq_params_vtbl =
 492 {
 493     eq_params_QueryInterface,
 494     eq_params_AddRef,
 495     eq_params_Release,
 496     eq_params_SetAllParameters,
 497     eq_params_GetAllParameters,
 498 };
 499
 500 static struct eq *impl_eq_from_effect(struct effect *iface)
 501 {
 502     return CONTAINING_RECORD(iface, struct eq, effect);
 503 }
 504
 505 static void *eq_query_interface(struct effect *iface, REFIID iid)
 506 {
 507     struct eq *effect = impl_eq_from_effect(iface);
 508
 509     if (IsEqualGUID(iid, &IID_IDirectSoundFXParamEq))
 510         return &effect->IDirectSoundFXParamEq_iface;
 511     return NULL;
 512 }
 513
 514 static void eq_destroy(struct effect *iface)
 515 {
 516     struct eq *effect = impl_eq_from_effect(iface);
 517
 518     free(effect);
 519 }
 520
 521 static const struct effect_ops eq_ops =
 522 {
 523     .destroy = eq_destroy,
 524     .query_interface = eq_query_interface,
 525 };
 526
 527 static HRESULT eq_create(IUnknown *outer, IUnknown **out)
 528 {
 529     struct eq *object;
 530
 531     if (!(object = calloc(1, sizeof(*object))))
 532         return E_OUTOFMEMORY;
 533
 534     effect_init(&object->effect, outer, &eq_ops);
 535     object->IDirectSoundFXParamEq_iface.lpVtbl = &eq_params_vtbl;
 536
 537     object->params.fCenter = 8000.0f;
 538     object->params.fBandwidth = 12.0f;
 539     object->params.fGain = 0.0f;
 540
 541     TRACE("Created equalizer effect %p.\n", object);
 542     *out = &object->effect.IUnknown_inner;
 543     return S_OK;
 544 }
 545
 546 struct reverb
 547 {
 548     struct effect effect;
 549     IDirectSoundFXI3DL2Reverb IDirectSoundFXI3DL2Reverb_iface;
 550     DSFXI3DL2Reverb params;
 551 };
 552
 553 static struct reverb *impl_from_IDirectSoundFXI3DL2Reverb(IDirectSoundFXI3DL2Reverb *iface)
 554 {
 555     return CONTAINING_RECORD(iface, struct reverb, IDirectSoundFXI3DL2Reverb_iface);
 556 }
 557
 558 static HRESULT WINAPI reverb_params_QueryInterface(IDirectSoundFXI3DL2Reverb *iface, REFIID iid, void **out)
 559 {
 560     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 561     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
 562 }
 563
 564 static ULONG WINAPI reverb_params_AddRef(IDirectSoundFXI3DL2Reverb *iface)
 565 {
 566     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 567     return IUnknown_AddRef(effect->effect.outer_unk);
 568 }
 569
 570 static ULONG WINAPI reverb_params_Release(IDirectSoundFXI3DL2Reverb *iface)
 571 {
 572     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 573     return IUnknown_Release(effect->effect.outer_unk);
 574 }
 575
 576 static HRESULT WINAPI reverb_params_SetAllParameters(IDirectSoundFXI3DL2Reverb *iface, const DSFXI3DL2Reverb *params)
 577 {
 578     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 579
 580     TRACE("effect %p, params %p.\n", effect, params);
 581
 582     EnterCriticalSection(&effect->effect.cs);
 583     effect->params = *params;
 584     LeaveCriticalSection(&effect->effect.cs);
 585     return S_OK;
 586 }
 587
 588 static HRESULT WINAPI reverb_params_GetAllParameters(IDirectSoundFXI3DL2Reverb *iface, DSFXI3DL2Reverb *params)
 589 {
 590     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 591
 592     TRACE("effect %p, params %p.\n", effect, params);
 593
 594     EnterCriticalSection(&effect->effect.cs);
 595     *params = effect->params;
 596     LeaveCriticalSection(&effect->effect.cs);
 597     return S_OK;
 598 }
 599
 600 static HRESULT WINAPI reverb_params_SetPreset(IDirectSoundFXI3DL2Reverb *iface, DWORD preset)
 601 {
 602     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 603
 604     FIXME("effect %p, preset %u, stub!\n", effect, preset);
 605
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI reverb_params_GetPreset(IDirectSoundFXI3DL2Reverb *iface, DWORD *preset)
 610 {
 611     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 612
 613     FIXME("effect %p, preset %p, stub!\n", effect, preset);
 614
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT WINAPI reverb_params_SetQuality(IDirectSoundFXI3DL2Reverb *iface, LONG quality)
 619 {
 620     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 621
 622     FIXME("effect %p, quality %u, stub!\n", effect, quality);
 623
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT WINAPI reverb_params_GetQuality(IDirectSoundFXI3DL2Reverb *iface, LONG *quality)
 628 {
 629     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 630
 631     FIXME("effect %p, quality %p, stub!\n", effect, quality);
 632
 633     return E_NOTIMPL;
 634 }
 635
 636 static const IDirectSoundFXI3DL2ReverbVtbl reverb_params_vtbl =
 637 {
 638     reverb_params_QueryInterface,
 639     reverb_params_AddRef,
 640     reverb_params_Release,
 641     reverb_params_SetAllParameters,
 642     reverb_params_GetAllParameters,
 643     reverb_params_SetPreset,
 644     reverb_params_GetPreset,
 645     reverb_params_SetQuality,
 646     reverb_params_GetQuality,
 647 };
 648
 649 static struct reverb *impl_reverb_from_effect(struct effect *iface)
 650 {
 651     return CONTAINING_RECORD(iface, struct reverb, effect);
 652 }
 653
 654 static void *reverb_query_interface(struct effect *iface, REFIID iid)
 655 {
 656     struct reverb *effect = impl_reverb_from_effect(iface);
 657
 658     if (IsEqualGUID(iid, &IID_IDirectSoundFXI3DL2Reverb))
 659         return &effect->IDirectSoundFXI3DL2Reverb_iface;
 660     return NULL;
 661 }
 662
 663 static void reverb_destroy(struct effect *iface)
 664 {
 665     struct reverb *effect = impl_reverb_from_effect(iface);
 666
 667     free(effect);
 668 }
 669
 670 static const struct effect_ops reverb_ops =
 671 {
 672     .destroy = reverb_destroy,
 673     .query_interface = reverb_query_interface,
 674 };
 675
 676 static HRESULT reverb_create(IUnknown *outer, IUnknown **out)
 677 {
 678     struct reverb *object;
 679
 680     if (!(object = calloc(1, sizeof(*object))))
 681         return E_OUTOFMEMORY;
 682
 683     effect_init(&object->effect, outer, &reverb_ops);
 684     object->IDirectSoundFXI3DL2Reverb_iface.lpVtbl = &reverb_params_vtbl;
 685
 686     object->params.lRoom                = DSFX_I3DL2REVERB_ROOM_DEFAULT;
 687     object->params.lRoomHF              = DSFX_I3DL2REVERB_ROOMHF_DEFAULT;
 688     object->params.flRoomRolloffFactor  = DSFX_I3DL2REVERB_ROOMROLLOFFFACTOR_DEFAULT;
 689     object->params.flDecayTime          = DSFX_I3DL2REVERB_DECAYTIME_DEFAULT;
 690     object->params.flDecayHFRatio       = DSFX_I3DL2REVERB_DECAYHFRATIO_DEFAULT;
 691     object->params.lReflections         = DSFX_I3DL2REVERB_REFLECTIONS_DEFAULT;
 692     object->params.flReflectionsDelay   = DSFX_I3DL2REVERB_REFLECTIONSDELAY_DEFAULT;
 693     object->params.lReverb              = DSFX_I3DL2REVERB_REVERB_DEFAULT;
 694     object->params.flReverbDelay        = DSFX_I3DL2REVERB_REVERBDELAY_DEFAULT;
 695     object->params.flDiffusion          = DSFX_I3DL2REVERB_DIFFUSION_DEFAULT;
 696     object->params.flDensity            = DSFX_I3DL2REVERB_DENSITY_DEFAULT;
 697     object->params.flHFReference        = DSFX_I3DL2REVERB_HFREFERENCE_DEFAULT;
 698
 699     TRACE("Created I3DL2 reverb effect %p.\n", object);
 700     *out = &object->effect.IUnknown_inner;
 701     return S_OK;
 702 }
 703
 704 struct waves_reverb
 705 {
 706     struct effect effect;
 707     IDirectSoundFXWavesReverb IDirectSoundFXWavesReverb_iface;
 708 };
 709
 710 static struct waves_reverb *impl_from_IDirectSoundFXWavesReverb(IDirectSoundFXWavesReverb *iface)
 711 {
 712     return CONTAINING_RECORD(iface, struct waves_reverb, IDirectSoundFXWavesReverb_iface);
 713 }
 714
 715 static HRESULT WINAPI waves_reverb_params_QueryInterface(IDirectSoundFXWavesReverb *iface, REFIID iid, void **out)
 716 {
 717     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 718     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
 719 }
 720
 721 static ULONG WINAPI waves_reverb_params_AddRef(IDirectSoundFXWavesReverb *iface)
 722 {
 723     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 724     return IUnknown_AddRef(effect->effect.outer_unk);
 725 }
 726
 727 static ULONG WINAPI waves_reverb_params_Release(IDirectSoundFXWavesReverb *iface)
 728 {
 729     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 730     return IUnknown_Release(effect->effect.outer_unk);
 731 }
 732
 733 static HRESULT WINAPI waves_reverb_params_SetAllParameters(IDirectSoundFXWavesReverb *iface, const DSFXWavesReverb *params)
 734 {
 735     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 736
 737     FIXME("effect %p, params %p, stub!\n", effect, params);
 738
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT WINAPI waves_reverb_params_GetAllParameters(IDirectSoundFXWavesReverb *iface, DSFXWavesReverb *params)
 743 {
 744     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 745
 746     FIXME("effect %p, params %p, stub!\n", effect, params);
 747
 748     return E_NOTIMPL;
 749 }
 750
 751 static const IDirectSoundFXWavesReverbVtbl waves_reverb_params_vtbl =
 752 {
 753     waves_reverb_params_QueryInterface,
 754     waves_reverb_params_AddRef,
 755     waves_reverb_params_Release,
 756     waves_reverb_params_SetAllParameters,
 757     waves_reverb_params_GetAllParameters,
 758 };
 759
 760 static struct waves_reverb *impl_waves_reverb_from_effect(struct effect *iface)
 761 {
 762     return CONTAINING_RECORD(iface, struct waves_reverb, effect);
 763 }
 764
 765 static void *waves_reverb_query_interface(struct effect *iface, REFIID iid)
 766 {
 767     struct waves_reverb *effect = impl_waves_reverb_from_effect(iface);
 768
 769     if (IsEqualGUID(iid, &IID_IDirectSoundFXWavesReverb))
 770         return &effect->IDirectSoundFXWavesReverb_iface;
 771     return NULL;
 772 }
 773
 774 static void waves_reverb_destroy(struct effect *iface)
 775 {
 776     struct waves_reverb *effect = impl_waves_reverb_from_effect(iface);
 777
 778     free(effect);
 779 }
 780
 781 static const struct effect_ops waves_reverb_ops =
 782 {
 783     .destroy = waves_reverb_destroy,
 784     .query_interface = waves_reverb_query_interface,
 785 };
 786
 787 static HRESULT waves_reverb_create(IUnknown *outer, IUnknown **out)
 788 {
 789     struct waves_reverb *object;
 790
 791     if (!(object = calloc(1, sizeof(*object))))
 792         return E_OUTOFMEMORY;
 793
 794     effect_init(&object->effect, outer, &waves_reverb_ops);
 795     object->IDirectSoundFXWavesReverb_iface.lpVtbl = &waves_reverb_params_vtbl;
 796
 797     TRACE("Created waves reverb effect %p.\n", object);
 798     *out = &object->effect.IUnknown_inner;
 799     return S_OK;
 800 }
 801
 802 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
 803 {
 804     switch(reason)
 805     {
 806     case DLL_WINE_PREATTACH:
 807         return FALSE;  /* prefer native version */
 808     case DLL_PROCESS_ATTACH:
 809         dsdmo_instance = instance;
 810         DisableThreadLibraryCalls(dsdmo_instance);
 811         break;
 812     }
 813
 814     return TRUE;
 815 }
 816
 817 struct class_factory
 818 {
 819     IClassFactory IClassFactory_iface;
 820     HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
 821 };
 822
 823 static struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
 824 {
 825     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
 826 }
 827
 828 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
 829 {
 830     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 831
 832     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory))
 833     {
 834         IClassFactory_AddRef(iface);
 835         *out = iface;
 836         return S_OK;
 837     }
 838
 839     *out = NULL;
 840     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(iid));
 841     return E_NOINTERFACE;
 842 }
 843
 844 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
 845 {
 846     return 2;
 847 }
 848
 849 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
 850 {
 851     return 1;
 852 }
 853
 854 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface,
 855         IUnknown *outer, REFIID iid, void **out)
 856 {
 857     struct class_factory *factory = impl_from_IClassFactory(iface);
 858     IUnknown *unk;
 859     HRESULT hr;
 860
 861     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 862
 863     *out = NULL;
 864
 865     if (outer && !IsEqualGUID(iid, &IID_IUnknown))
 866         return E_NOINTERFACE;
 867
 868     if (SUCCEEDED(hr = factory->create_instance(outer, &unk)))
 869     {
 870         hr = IUnknown_QueryInterface(unk, iid, out);
 871         IUnknown_Release(unk);
 872     }
 873     return hr;
 874 }
 875
 876 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL lock)
 877 {
 878     FIXME("lock %d, stub!\n", lock);
 879     return S_OK;
 880 }
 881
 882 static const IClassFactoryVtbl class_factory_vtbl =
 883 {
 884     class_factory_QueryInterface,
 885     class_factory_AddRef,
 886     class_factory_Release,
 887     class_factory_CreateInstance,
 888     class_factory_LockServer,
 889 };
 890
 891 static struct
 892 {
 893     const GUID *clsid;
 894     struct class_factory factory;
 895 }
 896 class_factories[] =
 897 {
 898     {&GUID_DSFX_STANDARD_I3DL2REVERB,   {{&class_factory_vtbl}, reverb_create}},
 899     {&GUID_DSFX_STANDARD_PARAMEQ,       {{&class_factory_vtbl}, eq_create}},
 900     {&GUID_DSFX_WAVES_REVERB,           {{&class_factory_vtbl}, waves_reverb_create}},
 901 };
 902
 903 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
 904 {
 905     unsigned int i;
 906
 907     TRACE("clsid %s, iid %s, out %p.\n", debugstr_guid(clsid), debugstr_guid(iid), out);
 908
 909     for (i = 0; i < ARRAY_SIZE(class_factories); ++i)
 910     {
 911         if (IsEqualGUID(clsid, class_factories[i].clsid))
 912             return IClassFactory_QueryInterface(&class_factories[i].factory.IClassFactory_iface, iid, out);
 913     }
 914
 915     FIXME("%s not available, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(clsid));
 916     return CLASS_E_CLASSNOTAVAILABLE;
 917 }
 918
 919 HRESULT WINAPI DllCanUnloadNow(void)
 920 {
 921     return S_FALSE;
 922 }
 923
 924 HRESULT WINAPI DllRegisterServer(void)
 925 {
 926     TRACE("()\n");
 927     return __wine_register_resources(dsdmo_instance);
 928 }
 929
 930 HRESULT WINAPI DllUnregisterServer(void)
 931 {
 932     TRACE("()\n");
 933     return __wine_unregister_resources(dsdmo_instance);
 934 }