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 "medparam.h"
  26 #include "dsound.h"
  27 #include "rpcproxy.h"
  28
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(dsdmo);
  32
  33 struct effect
  34 {
  35     IMediaObject IMediaObject_iface;
  36     IMediaObjectInPlace IMediaObjectInPlace_iface;
  37     IMediaParams IMediaParams_iface;
  38     IMediaParamInfo IMediaParamInfo_iface;
  39     IUnknown IUnknown_inner;
  40     IUnknown *outer_unk;
  41     LONG refcount;
  42
  43     CRITICAL_SECTION cs;
  44     WAVEFORMATEX format;
  45
  46     const struct effect_ops *ops;
  47 };
  48
  49 struct effect_ops
  50 {
  51     void *(*query_interface)(struct effect *effect, REFIID iid);
  52     void (*destroy)(struct effect *effect);
  53 };
  54
  55 static struct effect *impl_from_IUnknown(IUnknown *iface)
  56 {
  57     return CONTAINING_RECORD(iface, struct effect, IUnknown_inner);
  58 }
  59
  60 static HRESULT WINAPI effect_inner_QueryInterface(IUnknown *iface, REFIID iid, void **out)
  61 {
  62     struct effect *effect = impl_from_IUnknown(iface);
  63
  64     TRACE("effect %p, iid %s, out %p.\n", effect, debugstr_guid(iid), out);
  65
  66     if (IsEqualGUID(iid, &IID_IUnknown))
  67         *out = iface;
  68     else if (IsEqualGUID(iid, &IID_IMediaObject))
  69         *out = &effect->IMediaObject_iface;
  70     else if (IsEqualGUID(iid, &IID_IMediaObjectInPlace))
  71         *out = &effect->IMediaObjectInPlace_iface;
  72     else if (IsEqualGUID(iid, &IID_IMediaParams))
  73         *out = &effect->IMediaParams_iface;
  74     else if (IsEqualGUID(iid, &IID_IMediaParamInfo))
  75         *out = &effect->IMediaParamInfo_iface;
  76     else if (!(*out = effect->ops->query_interface(effect, iid)))
  77     {
  78         WARN("%s not implemented; returning E_NOINTERFACE.\n", debugstr_guid(iid));
  79         return E_NOINTERFACE;
  80     }
  81
  82     IUnknown_AddRef((IUnknown *)*out);
  83     return S_OK;
  84 }
  85
  86 static ULONG WINAPI effect_inner_AddRef(IUnknown *iface)
  87 {
  88     struct effect *effect = impl_from_IUnknown(iface);
  89     ULONG refcount = InterlockedIncrement(&effect->refcount);
  90
  91     TRACE("%p increasing refcount to %lu.\n", effect, refcount);
  92     return refcount;
  93 }
  94
  95 static ULONG WINAPI effect_inner_Release(IUnknown *iface)
  96 {
  97     struct effect *effect = impl_from_IUnknown(iface);
  98     ULONG refcount = InterlockedDecrement(&effect->refcount);
  99
 100     TRACE("%p decreasing refcount to %lu.\n", effect, refcount);
 101
 102     if (!refcount)
 103     {
 104         effect->cs.DebugInfo->Spare[0] = 0;
 105         DeleteCriticalSection(&effect->cs);
 106         effect->ops->destroy(effect);
 107     }
 108     return refcount;
 109 }
 110
 111 static const IUnknownVtbl effect_inner_vtbl =
 112 {
 113     effect_inner_QueryInterface,
 114     effect_inner_AddRef,
 115     effect_inner_Release,
 116 };
 117
 118 static struct effect *impl_from_IMediaObject(IMediaObject *iface)
 119 {
 120     return CONTAINING_RECORD(iface, struct effect, IMediaObject_iface);
 121 }
 122
 123 static HRESULT WINAPI effect_QueryInterface(IMediaObject *iface, REFIID iid, void **out)
 124 {
 125     struct effect *effect = impl_from_IMediaObject(iface);
 126     return IUnknown_QueryInterface(effect->outer_unk, iid, out);
 127 }
 128
 129 static ULONG WINAPI effect_AddRef(IMediaObject *iface)
 130 {
 131     struct effect *effect = impl_from_IMediaObject(iface);
 132     return IUnknown_AddRef(effect->outer_unk);
 133 }
 134
 135 static ULONG WINAPI effect_Release(IMediaObject *iface)
 136 {
 137     struct effect *effect = impl_from_IMediaObject(iface);
 138     return IUnknown_Release(effect->outer_unk);
 139 }
 140
 141 static HRESULT WINAPI effect_GetStreamCount(IMediaObject *iface, DWORD *input, DWORD *output)
 142 {
 143     FIXME("iface %p, input %p, output %p, stub!\n", iface, input, output);
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI effect_GetInputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
 148 {
 149     FIXME("iface %p, index %lu, flags %p, stub!\n", iface, index, flags);
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI effect_GetOutputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
 154 {
 155     FIXME("iface %p, index %lu, flags %p, stub!\n", iface, index, flags);
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI effect_GetInputType(IMediaObject *iface, DWORD index, DWORD type_index, DMO_MEDIA_TYPE *type)
 160 {
 161     FIXME("iface %p, index %lu, type_index %lu, type %p, stub!\n", iface, index, type_index, type);
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI effect_GetOutputType(IMediaObject *iface, DWORD index, DWORD type_index, DMO_MEDIA_TYPE *type)
 166 {
 167     FIXME("iface %p, index %lu, type_index %lu, type %p, stub!\n", iface, index, type_index, type);
 168     return E_NOTIMPL;
 169 }
 170
 171 static HRESULT WINAPI effect_SetInputType(IMediaObject *iface, DWORD index, const DMO_MEDIA_TYPE *type, DWORD flags)
 172 {
 173     struct effect *effect = impl_from_IMediaObject(iface);
 174     const WAVEFORMATEX *format;
 175
 176     TRACE("iface %p, index %lu, type %p, flags %#lx.\n", iface, index, type, flags);
 177
 178     if (flags & DMO_SET_TYPEF_CLEAR)
 179     {
 180         EnterCriticalSection(&effect->cs);
 181         memset(&effect->format, 0, sizeof(effect->format));
 182         LeaveCriticalSection(&effect->cs);
 183         return S_OK;
 184     }
 185
 186     if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
 187         return DMO_E_TYPE_NOT_ACCEPTED;
 188
 189     if (!IsEqualGUID(&type->subtype, &MEDIASUBTYPE_PCM)
 190             && !IsEqualGUID(&type->subtype, &MEDIASUBTYPE_IEEE_FLOAT))
 191         return DMO_E_TYPE_NOT_ACCEPTED;
 192
 193     if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))
 194         return DMO_E_TYPE_NOT_ACCEPTED;
 195
 196     format = (const WAVEFORMATEX *)type->pbFormat;
 197     if (format->wFormatTag == WAVE_FORMAT_PCM)
 198     {
 199         if (format->wBitsPerSample != 8 && format->wBitsPerSample != 16)
 200         {
 201             WARN("Rejecting %u-bit integer PCM.\n", format->wBitsPerSample);
 202             return DMO_E_TYPE_NOT_ACCEPTED;
 203         }
 204     }
 205     else if (format->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 206     {
 207         if (format->wBitsPerSample != 32)
 208         {
 209             WARN("Rejecting %u-bit float PCM.\n", format->wBitsPerSample);
 210             return DMO_E_TYPE_NOT_ACCEPTED;
 211         }
 212     }
 213     else
 214     {
 215         WARN("Rejecting tag %#x.\n", format->wFormatTag);
 216         return DMO_E_TYPE_NOT_ACCEPTED;
 217     }
 218
 219     if (format->nChannels != 1 && format->nChannels != 2)
 220     {
 221         WARN("Rejecting %u channels.\n", format->nChannels);
 222         return DMO_E_TYPE_NOT_ACCEPTED;
 223     }
 224
 225     EnterCriticalSection(&effect->cs);
 226     effect->format = *format;
 227     LeaveCriticalSection(&effect->cs);
 228
 229     return S_OK;
 230 }
 231
 232 static HRESULT WINAPI effect_SetOutputType(IMediaObject *iface, DWORD index, const DMO_MEDIA_TYPE *type, DWORD flags)
 233 {
 234     struct effect *effect = impl_from_IMediaObject(iface);
 235     HRESULT hr;
 236
 237     TRACE("iface %p, index %lu, type %p, flags %#lx.\n", iface, index, type, flags);
 238
 239     if (flags & DMO_SET_TYPEF_CLEAR)
 240         return S_OK;
 241
 242     if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
 243         return DMO_E_TYPE_NOT_ACCEPTED;
 244
 245     if (!IsEqualGUID(&type->subtype, &MEDIASUBTYPE_PCM)
 246             && !IsEqualGUID(&type->subtype, &MEDIASUBTYPE_IEEE_FLOAT))
 247         return DMO_E_TYPE_NOT_ACCEPTED;
 248
 249     if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))
 250         return DMO_E_TYPE_NOT_ACCEPTED;
 251
 252     EnterCriticalSection(&effect->cs);
 253     hr = memcmp(type->pbFormat, &effect->format, sizeof(WAVEFORMATEX)) ? DMO_E_TYPE_NOT_ACCEPTED : S_OK;
 254     LeaveCriticalSection(&effect->cs);
 255
 256     return hr;
 257 }
 258
 259 static HRESULT WINAPI effect_GetInputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
 260 {
 261     FIXME("iface %p, index %lu, type %p, stub!\n", iface, index, type);
 262     return E_NOTIMPL;
 263 }
 264
 265 static HRESULT WINAPI effect_GetOutputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
 266 {
 267     FIXME("iface %p, index %lu, type %p, stub!\n", iface, index, type);
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI effect_GetInputSizeInfo(IMediaObject *iface, DWORD index,
 272         DWORD *size, DWORD *lookahead, DWORD *alignment)
 273 {
 274     FIXME("iface %p, index %lu, size %p, lookahead %p, alignment %p, stub!\n", iface, index, size, lookahead, alignment);
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT WINAPI effect_GetOutputSizeInfo(IMediaObject *iface, DWORD index, DWORD *size, DWORD *alignment)
 279 {
 280     FIXME("iface %p, index %lu, size %p, alignment %p, stub!\n", iface, index, size, alignment);
 281     return E_NOTIMPL;
 282 }
 283
 284 static HRESULT WINAPI effect_GetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME *latency)
 285 {
 286     FIXME("iface %p, index %lu, latency %p, stub!\n", iface, index, latency);
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT WINAPI effect_SetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME latency)
 291 {
 292     FIXME("iface %p, index %lu, latency %s, stub!\n", iface, index, wine_dbgstr_longlong(latency));
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI effect_Flush(IMediaObject *iface)
 297 {
 298     FIXME("iface %p, stub!\n", iface);
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI effect_Discontinuity(IMediaObject *iface, DWORD index)
 303 {
 304     FIXME("iface %p, index %lu, stub!\n", iface, index);
 305     return E_NOTIMPL;
 306 }
 307
 308 static HRESULT WINAPI effect_AllocateStreamingResources(IMediaObject *iface)
 309 {
 310     FIXME("iface %p, stub!\n", iface);
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT WINAPI effect_FreeStreamingResources(IMediaObject *iface)
 315 {
 316     FIXME("iface %p, stub!\n", iface);
 317     return E_NOTIMPL;
 318 }
 319
 320 static HRESULT WINAPI effect_GetInputStatus(IMediaObject *iface, DWORD index, DWORD *flags)
 321 {
 322     FIXME("iface %p, index %lu, flags %p, stub!\n", iface, index, flags);
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI effect_ProcessInput(IMediaObject *iface, DWORD index,
 327     IMediaBuffer *buffer, DWORD flags, REFERENCE_TIME timestamp, REFERENCE_TIME timelength)
 328 {
 329     FIXME("iface %p, index %lu, buffer %p, flags %#lx, timestamp %s, timelength %s, stub!\n",
 330             iface, index, buffer, flags, wine_dbgstr_longlong(timestamp), wine_dbgstr_longlong(timelength));
 331     return E_NOTIMPL;
 332 }
 333
 334 static HRESULT WINAPI effect_ProcessOutput(IMediaObject *iface, DWORD flags,
 335         DWORD count, DMO_OUTPUT_DATA_BUFFER *buffers, DWORD *status)
 336 {
 337     FIXME("iface %p, flags %#lx, count %lu, buffers %p, status %p, stub!\n", iface, flags, count, buffers, status);
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI effect_Lock(IMediaObject *iface, LONG lock)
 342 {
 343     FIXME("iface %p, lock %ld, stub!\n", iface, lock);
 344     return E_NOTIMPL;
 345 }
 346
 347 static const IMediaObjectVtbl effect_vtbl =
 348 {
 349     effect_QueryInterface,
 350     effect_AddRef,
 351     effect_Release,
 352     effect_GetStreamCount,
 353     effect_GetInputStreamInfo,
 354     effect_GetOutputStreamInfo,
 355     effect_GetInputType,
 356     effect_GetOutputType,
 357     effect_SetInputType,
 358     effect_SetOutputType,
 359     effect_GetInputCurrentType,
 360     effect_GetOutputCurrentType,
 361     effect_GetInputSizeInfo,
 362     effect_GetOutputSizeInfo,
 363     effect_GetInputMaxLatency,
 364     effect_SetInputMaxLatency,
 365     effect_Flush,
 366     effect_Discontinuity,
 367     effect_AllocateStreamingResources,
 368     effect_FreeStreamingResources,
 369     effect_GetInputStatus,
 370     effect_ProcessInput,
 371     effect_ProcessOutput,
 372     effect_Lock,
 373 };
 374
 375 static struct effect *impl_from_IMediaObjectInPlace(IMediaObjectInPlace *iface)
 376 {
 377     return CONTAINING_RECORD(iface, struct effect, IMediaObjectInPlace_iface);
 378 }
 379
 380 static HRESULT WINAPI effect_inplace_QueryInterface(IMediaObjectInPlace *iface, REFIID iid, void **out)
 381 {
 382     struct effect *effect = impl_from_IMediaObjectInPlace(iface);
 383     return IUnknown_QueryInterface(effect->outer_unk, iid, out);
 384 }
 385
 386 static ULONG WINAPI effect_inplace_AddRef(IMediaObjectInPlace *iface)
 387 {
 388     struct effect *effect = impl_from_IMediaObjectInPlace(iface);
 389     return IUnknown_AddRef(effect->outer_unk);
 390 }
 391
 392 static ULONG WINAPI effect_inplace_Release(IMediaObjectInPlace *iface)
 393 {
 394     struct effect *effect = impl_from_IMediaObjectInPlace(iface);
 395     return IUnknown_Release(effect->outer_unk);
 396 }
 397
 398 static HRESULT WINAPI effect_inplace_Process(IMediaObjectInPlace *iface, ULONG size,
 399         BYTE *data, REFERENCE_TIME start, DWORD flags)
 400 {
 401     FIXME("iface %p, size %lu, data %p, start %s, flags %#lx, stub!\n",
 402             iface, size, data, wine_dbgstr_longlong(start), flags);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI effect_inplace_Clone(IMediaObjectInPlace *iface, IMediaObjectInPlace **out)
 407 {
 408     FIXME("iface %p, out %p, stub!\n", iface, out);
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI effect_inplace_GetLatency(IMediaObjectInPlace *iface, REFERENCE_TIME *latency)
 413 {
 414     FIXME("iface %p, latency %p, stub!\n", iface, latency);
 415     return E_NOTIMPL;
 416 }
 417
 418 static const IMediaObjectInPlaceVtbl effect_inplace_vtbl =
 419 {
 420     effect_inplace_QueryInterface,
 421     effect_inplace_AddRef,
 422     effect_inplace_Release,
 423     effect_inplace_Process,
 424     effect_inplace_Clone,
 425     effect_inplace_GetLatency,
 426 };
 427
 428 static struct effect *impl_from_IMediaParams(IMediaParams *iface)
 429 {
 430     return CONTAINING_RECORD(iface, struct effect, IMediaParams_iface);
 431 }
 432
 433 static HRESULT WINAPI effect_media_params_QueryInterface(IMediaParams *iface, REFIID iid, void **out)
 434 {
 435     struct effect *effect = impl_from_IMediaParams(iface);
 436     return IUnknown_QueryInterface(effect->outer_unk, iid, out);
 437 }
 438
 439 static ULONG WINAPI effect_media_params_AddRef(IMediaParams *iface)
 440 {
 441     struct effect *effect = impl_from_IMediaParams(iface);
 442     return IUnknown_AddRef(effect->outer_unk);
 443 }
 444
 445 static ULONG WINAPI effect_media_params_Release(IMediaParams *iface)
 446 {
 447     struct effect *effect = impl_from_IMediaParams(iface);
 448     return IUnknown_Release(effect->outer_unk);
 449 }
 450
 451 static HRESULT WINAPI effect_media_params_GetParam(IMediaParams *iface, DWORD index, MP_DATA *data)
 452 {
 453     FIXME("iface %p, index %lu, data %p, stub!\n", iface, index, data);
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI effect_media_params_SetParam(IMediaParams *iface, DWORD index, MP_DATA data)
 458 {
 459     FIXME("iface %p, index %lu, data %f, stub!\n", iface, index, data);
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI effect_media_params_AddEnvelope(IMediaParams *iface, DWORD index, DWORD count,
 464                                                       MP_ENVELOPE_SEGMENT *segments)
 465 {
 466     FIXME("iface %p, index %lu, count %lu, segments %p, stub!\n", iface, index, count, segments);
 467     return E_NOTIMPL;
 468 }
 469
 470 static HRESULT WINAPI effect_media_params_FlushEnvelope(IMediaParams *iface, DWORD index,
 471                                                         REFERENCE_TIME start, REFERENCE_TIME end)
 472 {
 473     FIXME("iface %p, index %lu, start %s, end %s, stub!\n", iface, index,
 474           wine_dbgstr_longlong(start), wine_dbgstr_longlong(end));
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI effect_media_params_SetTimeFormat(IMediaParams *iface, GUID guid,
 479                                                         MP_TIMEDATA time_data)
 480 {
 481     FIXME("iface %p, guid %s, time_data %lx, stub!\n", iface, wine_dbgstr_guid(&guid), time_data);
 482     return E_NOTIMPL;
 483 }
 484
 485 static const IMediaParamsVtbl effect_media_params_vtbl =
 486 {
 487     effect_media_params_QueryInterface,
 488     effect_media_params_AddRef,
 489     effect_media_params_Release,
 490     effect_media_params_GetParam,
 491     effect_media_params_SetParam,
 492     effect_media_params_AddEnvelope,
 493     effect_media_params_FlushEnvelope,
 494     effect_media_params_SetTimeFormat,
 495 };
 496
 497 static struct effect *impl_from_IMediaParamInfo(IMediaParamInfo *iface)
 498 {
 499     return CONTAINING_RECORD(iface, struct effect, IMediaParamInfo_iface);
 500 }
 501
 502 static HRESULT WINAPI effect_media_param_info_QueryInterface(IMediaParamInfo *iface, REFIID iid, void **out)
 503 {
 504     struct effect *effect = impl_from_IMediaParamInfo(iface);
 505     return IUnknown_QueryInterface(effect->outer_unk, iid, out);
 506 }
 507
 508 static ULONG WINAPI effect_media_param_info_AddRef(IMediaParamInfo *iface)
 509 {
 510     struct effect *effect = impl_from_IMediaParamInfo(iface);
 511     return IUnknown_AddRef(effect->outer_unk);
 512 }
 513
 514 static ULONG WINAPI effect_media_param_info_Release(IMediaParamInfo *iface)
 515 {
 516     struct effect *effect = impl_from_IMediaParamInfo(iface);
 517     return IUnknown_Release(effect->outer_unk);
 518 }
 519
 520 static HRESULT WINAPI effect_media_param_info_GetParamCount(IMediaParamInfo *iface, DWORD *count)
 521 {
 522     FIXME("iface %p, count %p, stub!\n", iface, count);
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI effect_media_param_info_GetParamInfo(IMediaParamInfo *iface, DWORD index, MP_PARAMINFO *info)
 527 {
 528     FIXME("iface %p, index %lu, info %p, stub!\n", iface, index, info);
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI effect_media_param_info_GetParamText(IMediaParamInfo *iface, DWORD index, WCHAR **text)
 533 {
 534     FIXME("iface %p, index %lu, text %p, stub!\n", iface, index, text);
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI effect_media_param_info_GetNumTimeFormats(IMediaParamInfo *iface, DWORD *count)
 539 {
 540     FIXME("iface %p, count %p, stub!\n", iface, count);
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI effect_media_param_info_GetSupportedTimeFormat(IMediaParamInfo *iface, DWORD index, GUID *guid)
 545 {
 546     FIXME("iface %p, index %lu, guid %p, stub!\n", iface, index, guid);
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI effect_media_param_info_GetCurrentTimeFormat(IMediaParamInfo *iface, GUID *guid, MP_TIMEDATA *time_data)
 551 {
 552     FIXME("iface %p, guid %p, time_data %p, stub!\n", iface, guid, time_data);
 553     return E_NOTIMPL;
 554 }
 555
 556 static const IMediaParamInfoVtbl effect_media_param_info_vtbl =
 557 {
 558     effect_media_param_info_QueryInterface,
 559     effect_media_param_info_AddRef,
 560     effect_media_param_info_Release,
 561     effect_media_param_info_GetParamCount,
 562     effect_media_param_info_GetParamInfo,
 563     effect_media_param_info_GetParamText,
 564     effect_media_param_info_GetNumTimeFormats,
 565     effect_media_param_info_GetSupportedTimeFormat,
 566     effect_media_param_info_GetCurrentTimeFormat,
 567 };
 568
 569 static void effect_init(struct effect *effect, IUnknown *outer, const struct effect_ops *ops)
 570 {
 571     effect->outer_unk = outer ? outer : &effect->IUnknown_inner;
 572     effect->refcount = 1;
 573     effect->IUnknown_inner.lpVtbl = &effect_inner_vtbl;
 574     effect->IMediaObject_iface.lpVtbl = &effect_vtbl;
 575     effect->IMediaObjectInPlace_iface.lpVtbl = &effect_inplace_vtbl;
 576     effect->IMediaParams_iface.lpVtbl = &effect_media_params_vtbl;
 577     effect->IMediaParamInfo_iface.lpVtbl = &effect_media_param_info_vtbl;
 578
 579     InitializeCriticalSection(&effect->cs);
 580     effect->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": effect.cs");
 581
 582     effect->ops = ops;
 583 }
 584
 585 struct eq
 586 {
 587     struct effect effect;
 588     IDirectSoundFXParamEq IDirectSoundFXParamEq_iface;
 589     DSFXParamEq params;
 590 };
 591
 592 static struct eq *impl_from_IDirectSoundFXParamEq(IDirectSoundFXParamEq *iface)
 593 {
 594     return CONTAINING_RECORD(iface, struct eq, IDirectSoundFXParamEq_iface);
 595 }
 596
 597 static HRESULT WINAPI eq_params_QueryInterface(IDirectSoundFXParamEq *iface, REFIID iid, void **out)
 598 {
 599     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 600     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
 601 }
 602
 603 static ULONG WINAPI eq_params_AddRef(IDirectSoundFXParamEq *iface)
 604 {
 605     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 606     return IUnknown_AddRef(effect->effect.outer_unk);
 607 }
 608
 609 static ULONG WINAPI eq_params_Release(IDirectSoundFXParamEq *iface)
 610 {
 611     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 612     return IUnknown_Release(effect->effect.outer_unk);
 613 }
 614
 615 static HRESULT WINAPI eq_params_SetAllParameters(IDirectSoundFXParamEq *iface, const DSFXParamEq *params)
 616 {
 617     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 618
 619     TRACE("effect %p, params %p.\n", effect, params);
 620
 621     EnterCriticalSection(&effect->effect.cs);
 622     effect->params = *params;
 623     LeaveCriticalSection(&effect->effect.cs);
 624     return S_OK;
 625 }
 626
 627 static HRESULT WINAPI eq_params_GetAllParameters(IDirectSoundFXParamEq *iface, DSFXParamEq *params)
 628 {
 629     struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
 630
 631     TRACE("effect %p, params %p.\n", effect, params);
 632
 633     EnterCriticalSection(&effect->effect.cs);
 634     *params = effect->params;
 635     LeaveCriticalSection(&effect->effect.cs);
 636     return S_OK;
 637 }
 638
 639 static const IDirectSoundFXParamEqVtbl eq_params_vtbl =
 640 {
 641     eq_params_QueryInterface,
 642     eq_params_AddRef,
 643     eq_params_Release,
 644     eq_params_SetAllParameters,
 645     eq_params_GetAllParameters,
 646 };
 647
 648 static struct eq *impl_eq_from_effect(struct effect *iface)
 649 {
 650     return CONTAINING_RECORD(iface, struct eq, effect);
 651 }
 652
 653 static void *eq_query_interface(struct effect *iface, REFIID iid)
 654 {
 655     struct eq *effect = impl_eq_from_effect(iface);
 656
 657     if (IsEqualGUID(iid, &IID_IDirectSoundFXParamEq))
 658         return &effect->IDirectSoundFXParamEq_iface;
 659     return NULL;
 660 }
 661
 662 static void eq_destroy(struct effect *iface)
 663 {
 664     struct eq *effect = impl_eq_from_effect(iface);
 665
 666     free(effect);
 667 }
 668
 669 static const struct effect_ops eq_ops =
 670 {
 671     .destroy = eq_destroy,
 672     .query_interface = eq_query_interface,
 673 };
 674
 675 static HRESULT eq_create(IUnknown *outer, IUnknown **out)
 676 {
 677     struct eq *object;
 678
 679     if (!(object = calloc(1, sizeof(*object))))
 680         return E_OUTOFMEMORY;
 681
 682     effect_init(&object->effect, outer, &eq_ops);
 683     object->IDirectSoundFXParamEq_iface.lpVtbl = &eq_params_vtbl;
 684
 685     object->params.fCenter = 8000.0f;
 686     object->params.fBandwidth = 12.0f;
 687     object->params.fGain = 0.0f;
 688
 689     TRACE("Created equalizer effect %p.\n", object);
 690     *out = &object->effect.IUnknown_inner;
 691     return S_OK;
 692 }
 693
 694 struct reverb
 695 {
 696     struct effect effect;
 697     IDirectSoundFXI3DL2Reverb IDirectSoundFXI3DL2Reverb_iface;
 698     DSFXI3DL2Reverb params;
 699 };
 700
 701 static struct reverb *impl_from_IDirectSoundFXI3DL2Reverb(IDirectSoundFXI3DL2Reverb *iface)
 702 {
 703     return CONTAINING_RECORD(iface, struct reverb, IDirectSoundFXI3DL2Reverb_iface);
 704 }
 705
 706 static HRESULT WINAPI reverb_params_QueryInterface(IDirectSoundFXI3DL2Reverb *iface, REFIID iid, void **out)
 707 {
 708     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 709     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
 710 }
 711
 712 static ULONG WINAPI reverb_params_AddRef(IDirectSoundFXI3DL2Reverb *iface)
 713 {
 714     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 715     return IUnknown_AddRef(effect->effect.outer_unk);
 716 }
 717
 718 static ULONG WINAPI reverb_params_Release(IDirectSoundFXI3DL2Reverb *iface)
 719 {
 720     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 721     return IUnknown_Release(effect->effect.outer_unk);
 722 }
 723
 724 static HRESULT WINAPI reverb_params_SetAllParameters(IDirectSoundFXI3DL2Reverb *iface, const DSFXI3DL2Reverb *params)
 725 {
 726     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 727
 728     TRACE("effect %p, params %p.\n", effect, params);
 729
 730     EnterCriticalSection(&effect->effect.cs);
 731     effect->params = *params;
 732     LeaveCriticalSection(&effect->effect.cs);
 733     return S_OK;
 734 }
 735
 736 static HRESULT WINAPI reverb_params_GetAllParameters(IDirectSoundFXI3DL2Reverb *iface, DSFXI3DL2Reverb *params)
 737 {
 738     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 739
 740     TRACE("effect %p, params %p.\n", effect, params);
 741
 742     EnterCriticalSection(&effect->effect.cs);
 743     *params = effect->params;
 744     LeaveCriticalSection(&effect->effect.cs);
 745     return S_OK;
 746 }
 747
 748 static HRESULT WINAPI reverb_params_SetPreset(IDirectSoundFXI3DL2Reverb *iface, DWORD preset)
 749 {
 750     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 751
 752     FIXME("effect %p, preset %lu, stub!\n", effect, preset);
 753
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI reverb_params_GetPreset(IDirectSoundFXI3DL2Reverb *iface, DWORD *preset)
 758 {
 759     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 760
 761     FIXME("effect %p, preset %p, stub!\n", effect, preset);
 762
 763     return E_NOTIMPL;
 764 }
 765
 766 static HRESULT WINAPI reverb_params_SetQuality(IDirectSoundFXI3DL2Reverb *iface, LONG quality)
 767 {
 768     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 769
 770     FIXME("effect %p, quality %lu, stub!\n", effect, quality);
 771
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI reverb_params_GetQuality(IDirectSoundFXI3DL2Reverb *iface, LONG *quality)
 776 {
 777     struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
 778
 779     FIXME("effect %p, quality %p, stub!\n", effect, quality);
 780
 781     return E_NOTIMPL;
 782 }
 783
 784 static const IDirectSoundFXI3DL2ReverbVtbl reverb_params_vtbl =
 785 {
 786     reverb_params_QueryInterface,
 787     reverb_params_AddRef,
 788     reverb_params_Release,
 789     reverb_params_SetAllParameters,
 790     reverb_params_GetAllParameters,
 791     reverb_params_SetPreset,
 792     reverb_params_GetPreset,
 793     reverb_params_SetQuality,
 794     reverb_params_GetQuality,
 795 };
 796
 797 static struct reverb *impl_reverb_from_effect(struct effect *iface)
 798 {
 799     return CONTAINING_RECORD(iface, struct reverb, effect);
 800 }
 801
 802 static void *reverb_query_interface(struct effect *iface, REFIID iid)
 803 {
 804     struct reverb *effect = impl_reverb_from_effect(iface);
 805
 806     if (IsEqualGUID(iid, &IID_IDirectSoundFXI3DL2Reverb))
 807         return &effect->IDirectSoundFXI3DL2Reverb_iface;
 808     return NULL;
 809 }
 810
 811 static void reverb_destroy(struct effect *iface)
 812 {
 813     struct reverb *effect = impl_reverb_from_effect(iface);
 814
 815     free(effect);
 816 }
 817
 818 static const struct effect_ops reverb_ops =
 819 {
 820     .destroy = reverb_destroy,
 821     .query_interface = reverb_query_interface,
 822 };
 823
 824 static HRESULT reverb_create(IUnknown *outer, IUnknown **out)
 825 {
 826     struct reverb *object;
 827
 828     if (!(object = calloc(1, sizeof(*object))))
 829         return E_OUTOFMEMORY;
 830
 831     effect_init(&object->effect, outer, &reverb_ops);
 832     object->IDirectSoundFXI3DL2Reverb_iface.lpVtbl = &reverb_params_vtbl;
 833
 834     object->params.lRoom                = DSFX_I3DL2REVERB_ROOM_DEFAULT;
 835     object->params.lRoomHF              = DSFX_I3DL2REVERB_ROOMHF_DEFAULT;
 836     object->params.flRoomRolloffFactor  = DSFX_I3DL2REVERB_ROOMROLLOFFFACTOR_DEFAULT;
 837     object->params.flDecayTime          = DSFX_I3DL2REVERB_DECAYTIME_DEFAULT;
 838     object->params.flDecayHFRatio       = DSFX_I3DL2REVERB_DECAYHFRATIO_DEFAULT;
 839     object->params.lReflections         = DSFX_I3DL2REVERB_REFLECTIONS_DEFAULT;
 840     object->params.flReflectionsDelay   = DSFX_I3DL2REVERB_REFLECTIONSDELAY_DEFAULT;
 841     object->params.lReverb              = DSFX_I3DL2REVERB_REVERB_DEFAULT;
 842     object->params.flReverbDelay        = DSFX_I3DL2REVERB_REVERBDELAY_DEFAULT;
 843     object->params.flDiffusion          = DSFX_I3DL2REVERB_DIFFUSION_DEFAULT;
 844     object->params.flDensity            = DSFX_I3DL2REVERB_DENSITY_DEFAULT;
 845     object->params.flHFReference        = DSFX_I3DL2REVERB_HFREFERENCE_DEFAULT;
 846
 847     TRACE("Created I3DL2 reverb effect %p.\n", object);
 848     *out = &object->effect.IUnknown_inner;
 849     return S_OK;
 850 }
 851
 852 struct waves_reverb
 853 {
 854     struct effect effect;
 855     IDirectSoundFXWavesReverb IDirectSoundFXWavesReverb_iface;
 856 };
 857
 858 static struct waves_reverb *impl_from_IDirectSoundFXWavesReverb(IDirectSoundFXWavesReverb *iface)
 859 {
 860     return CONTAINING_RECORD(iface, struct waves_reverb, IDirectSoundFXWavesReverb_iface);
 861 }
 862
 863 static HRESULT WINAPI waves_reverb_params_QueryInterface(IDirectSoundFXWavesReverb *iface, REFIID iid, void **out)
 864 {
 865     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 866     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
 867 }
 868
 869 static ULONG WINAPI waves_reverb_params_AddRef(IDirectSoundFXWavesReverb *iface)
 870 {
 871     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 872     return IUnknown_AddRef(effect->effect.outer_unk);
 873 }
 874
 875 static ULONG WINAPI waves_reverb_params_Release(IDirectSoundFXWavesReverb *iface)
 876 {
 877     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 878     return IUnknown_Release(effect->effect.outer_unk);
 879 }
 880
 881 static HRESULT WINAPI waves_reverb_params_SetAllParameters(IDirectSoundFXWavesReverb *iface, const DSFXWavesReverb *params)
 882 {
 883     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 884
 885     FIXME("effect %p, params %p, stub!\n", effect, params);
 886
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT WINAPI waves_reverb_params_GetAllParameters(IDirectSoundFXWavesReverb *iface, DSFXWavesReverb *params)
 891 {
 892     struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
 893
 894     FIXME("effect %p, params %p, stub!\n", effect, params);
 895
 896     return E_NOTIMPL;
 897 }
 898
 899 static const IDirectSoundFXWavesReverbVtbl waves_reverb_params_vtbl =
 900 {
 901     waves_reverb_params_QueryInterface,
 902     waves_reverb_params_AddRef,
 903     waves_reverb_params_Release,
 904     waves_reverb_params_SetAllParameters,
 905     waves_reverb_params_GetAllParameters,
 906 };
 907
 908 static struct waves_reverb *impl_waves_reverb_from_effect(struct effect *iface)
 909 {
 910     return CONTAINING_RECORD(iface, struct waves_reverb, effect);
 911 }
 912
 913 static void *waves_reverb_query_interface(struct effect *iface, REFIID iid)
 914 {
 915     struct waves_reverb *effect = impl_waves_reverb_from_effect(iface);
 916
 917     if (IsEqualGUID(iid, &IID_IDirectSoundFXWavesReverb))
 918         return &effect->IDirectSoundFXWavesReverb_iface;
 919     return NULL;
 920 }
 921
 922 static void waves_reverb_destroy(struct effect *iface)
 923 {
 924     struct waves_reverb *effect = impl_waves_reverb_from_effect(iface);
 925
 926     free(effect);
 927 }
 928
 929 static const struct effect_ops waves_reverb_ops =
 930 {
 931     .destroy = waves_reverb_destroy,
 932     .query_interface = waves_reverb_query_interface,
 933 };
 934
 935 static HRESULT waves_reverb_create(IUnknown *outer, IUnknown **out)
 936 {
 937     struct waves_reverb *object;
 938
 939     if (!(object = calloc(1, sizeof(*object))))
 940         return E_OUTOFMEMORY;
 941
 942     effect_init(&object->effect, outer, &waves_reverb_ops);
 943     object->IDirectSoundFXWavesReverb_iface.lpVtbl = &waves_reverb_params_vtbl;
 944
 945     TRACE("Created waves reverb effect %p.\n", object);
 946     *out = &object->effect.IUnknown_inner;
 947     return S_OK;
 948 }
 949
 950 struct dmo_echofx
 951 {
 952     struct effect effect;
 953     IDirectSoundFXEcho  IDirectSoundFXEcho_iface;
 954 };
 955
 956 static inline struct dmo_echofx *impl_from_IDirectSoundFXEcho(IDirectSoundFXEcho *iface)
 957 {
 958     return CONTAINING_RECORD(iface, struct dmo_echofx, IDirectSoundFXEcho_iface);
 959 }
 960
 961 static HRESULT WINAPI echofx_QueryInterface(IDirectSoundFXEcho *iface, REFIID iid, void **out)
 962 {
 963     struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
 964     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
 965 }
 966
 967 static ULONG WINAPI echofx_AddRef(IDirectSoundFXEcho *iface)
 968 {
 969     struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
 970     return IUnknown_AddRef(effect->effect.outer_unk);
 971 }
 972
 973 static ULONG WINAPI echofx_Release(IDirectSoundFXEcho *iface)
 974 {
 975     struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
 976     return IUnknown_Release(effect->effect.outer_unk);
 977 }
 978
 979 static HRESULT WINAPI echofx_SetAllParameters(IDirectSoundFXEcho *iface, const DSFXEcho *echo)
 980 {
 981     struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
 982     FIXME("(%p) %p\n", effect, echo);
 983
 984     return E_NOTIMPL;
 985 }
 986
 987 static HRESULT WINAPI echofx_GetAllParameters(IDirectSoundFXEcho *iface, DSFXEcho *echo)
 988 {
 989     struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
 990     FIXME("(%p) %p\n", effect, echo);
 991
 992     return E_NOTIMPL;
 993 }
 994
 995 static const struct IDirectSoundFXEchoVtbl echofx_vtbl =
 996 {
 997     echofx_QueryInterface,
 998     echofx_AddRef,
 999     echofx_Release,
1000     echofx_SetAllParameters,
1001     echofx_GetAllParameters
1002 };
1003
1004 static struct dmo_echofx *impl_echo_from_effect(struct effect *iface)
1005 {
1006     return CONTAINING_RECORD(iface, struct dmo_echofx, effect);
1007 }
1008
1009 static void *echo_query_interface(struct effect *iface, REFIID iid)
1010 {
1011     struct dmo_echofx *effect = impl_echo_from_effect(iface);
1012
1013     if (IsEqualGUID(iid, &IID_IDirectSoundFXEcho))
1014         return &effect->IDirectSoundFXEcho_iface;
1015     return NULL;
1016 }
1017
1018 static void echo_destroy(struct effect *iface)
1019 {
1020     struct dmo_echofx *effect = impl_echo_from_effect(iface);
1021
1022     free(effect);
1023 }
1024
1025 static const struct effect_ops echo_ops =
1026 {
1027     .destroy = echo_destroy,
1028     .query_interface = echo_query_interface,
1029 };
1030
1031 static HRESULT echo_create(IUnknown *outer, IUnknown **out)
1032 {
1033     struct dmo_echofx *object;
1034
1035     if (!(object = calloc(1, sizeof(*object))))
1036         return E_OUTOFMEMORY;
1037
1038     effect_init(&object->effect, outer, &echo_ops);
1039     object->IDirectSoundFXEcho_iface.lpVtbl = &echofx_vtbl;
1040
1041     TRACE("Created echo effect %p.\n", object);
1042     *out = &object->effect.IUnknown_inner;
1043     return S_OK;
1044 }
1045
1046 struct dmo_compressorfx
1047 {
1048     struct effect effect;
1049     IDirectSoundFXCompressor IDirectSoundFXCompressor_iface;
1050 };
1051
1052 static inline struct dmo_compressorfx *impl_from_IDirectSoundFXCompressor(IDirectSoundFXCompressor *iface)
1053 {
1054     return CONTAINING_RECORD(iface, struct dmo_compressorfx, IDirectSoundFXCompressor_iface);
1055 }
1056
1057 static HRESULT WINAPI compressorfx_QueryInterface(IDirectSoundFXCompressor *iface, REFIID iid, void **out)
1058 {
1059     struct dmo_compressorfx *effect = impl_from_IDirectSoundFXCompressor(iface);
1060     return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
1061 }
1062
1063 static ULONG WINAPI compressorfx_AddRef(IDirectSoundFXCompressor *iface)
1064 {
1065     struct dmo_compressorfx *effect = impl_from_IDirectSoundFXCompressor(iface);
1066     return IUnknown_AddRef(effect->effect.outer_unk);
1067 }
1068
1069 static ULONG WINAPI compressorfx_Release(IDirectSoundFXCompressor *iface)
1070 {
1071     struct dmo_compressorfx *effect = impl_from_IDirectSoundFXCompressor(iface);
1072     return IUnknown_Release(effect->effect.outer_unk);
1073 }
1074
1075 static HRESULT WINAPI compressorfx_SetAllParameters(IDirectSoundFXCompressor *iface, const DSFXCompressor *compressor)
1076 {
1077     struct dmo_compressorfx *This = impl_from_IDirectSoundFXCompressor(iface);
1078     FIXME("(%p) %p\n", This, compressor);
1079
1080     return E_NOTIMPL;
1081 }
1082
1083 static HRESULT WINAPI compressorfx_GetAllParameters(IDirectSoundFXCompressor *iface, DSFXCompressor *compressor)
1084 {
1085     struct dmo_compressorfx *This = impl_from_IDirectSoundFXCompressor(iface);
1086     FIXME("(%p) %p\n", This, compressor);
1087
1088     return E_NOTIMPL;
1089 }
1090
1091 static const struct IDirectSoundFXCompressorVtbl compressor_vtbl =
1092 {
1093     compressorfx_QueryInterface,
1094     compressorfx_AddRef,
1095     compressorfx_Release,
1096     compressorfx_SetAllParameters,
1097     compressorfx_GetAllParameters
1098 };
1099
1100 static struct dmo_compressorfx *impl_compressor_from_effect(struct effect *iface)
1101 {
1102     return CONTAINING_RECORD(iface, struct dmo_compressorfx, effect);
1103 }
1104
1105 static void *compressor_query_interface(struct effect *iface, REFIID iid)
1106 {
1107     struct dmo_compressorfx *effect = impl_compressor_from_effect(iface);
1108
1109     if (IsEqualGUID(iid, &IID_IDirectSoundFXCompressor))
1110         return &effect->IDirectSoundFXCompressor_iface;
1111     return NULL;
1112 }
1113
1114 static void compressor_destroy(struct effect *iface)
1115 {
1116     struct dmo_compressorfx *effect = impl_compressor_from_effect(iface);
1117
1118     free(effect);
1119 }
1120
1121 static const struct effect_ops compressor_ops =
1122 {
1123     .destroy = compressor_destroy,
1124     .query_interface = compressor_query_interface,
1125 };
1126
1127 static HRESULT compressor_create(IUnknown *outer, IUnknown **out)
1128 {
1129     struct dmo_compressorfx *object;
1130
1131     if (!(object = calloc(1, sizeof(*object))))
1132         return E_OUTOFMEMORY;
1133
1134     effect_init(&object->effect, outer, &compressor_ops);
1135     object->IDirectSoundFXCompressor_iface.lpVtbl = &compressor_vtbl;
1136
1137     TRACE("Created compressor effect %p.\n", object);
1138     *out = &object->effect.IUnknown_inner;
1139     return S_OK;
1140 }
1141
1142 struct class_factory
1143 {
1144     IClassFactory IClassFactory_iface;
1145     HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
1146 };
1147
1148 static struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
1149 {
1150     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
1151 }
1152
1153 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
1154 {
1155     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1156
1157     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory))
1158     {
1159         IClassFactory_AddRef(iface);
1160         *out = iface;
1161         return S_OK;
1162     }
1163
1164     *out = NULL;
1165     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(iid));
1166     return E_NOINTERFACE;
1167 }
1168
1169 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
1170 {
1171     return 2;
1172 }
1173
1174 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
1175 {
1176     return 1;
1177 }
1178
1179 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface,
1180         IUnknown *outer, REFIID iid, void **out)
1181 {
1182     struct class_factory *factory = impl_from_IClassFactory(iface);
1183     IUnknown *unk;
1184     HRESULT hr;
1185
1186     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
1187
1188     *out = NULL;
1189
1190     if (outer && !IsEqualGUID(iid, &IID_IUnknown))
1191         return E_NOINTERFACE;
1192
1193     if (SUCCEEDED(hr = factory->create_instance(outer, &unk)))
1194     {
1195         hr = IUnknown_QueryInterface(unk, iid, out);
1196         IUnknown_Release(unk);
1197     }
1198     return hr;
1199 }
1200
1201 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL lock)
1202 {
1203     FIXME("lock %d, stub!\n", lock);
1204     return S_OK;
1205 }
1206
1207 static const IClassFactoryVtbl class_factory_vtbl =
1208 {
1209     class_factory_QueryInterface,
1210     class_factory_AddRef,
1211     class_factory_Release,
1212     class_factory_CreateInstance,
1213     class_factory_LockServer,
1214 };
1215
1216 static struct
1217 {
1218     const GUID *clsid;
1219     struct class_factory factory;
1220 }
1221 class_factories[] =
1222 {
1223     {&GUID_DSFX_STANDARD_I3DL2REVERB,   {{&class_factory_vtbl}, reverb_create}},
1224     {&GUID_DSFX_STANDARD_PARAMEQ,       {{&class_factory_vtbl}, eq_create}},
1225     {&GUID_DSFX_WAVES_REVERB,           {{&class_factory_vtbl}, waves_reverb_create}},
1226     {&GUID_DSFX_STANDARD_ECHO,          {{&class_factory_vtbl}, echo_create}},
1227     {&GUID_DSFX_STANDARD_COMPRESSOR,    {{&class_factory_vtbl}, compressor_create}},
1228 };
1229
1230 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
1231 {
1232     unsigned int i;
1233
1234     TRACE("clsid %s, iid %s, out %p.\n", debugstr_guid(clsid), debugstr_guid(iid), out);
1235
1236     for (i = 0; i < ARRAY_SIZE(class_factories); ++i)
1237     {
1238         if (IsEqualGUID(clsid, class_factories[i].clsid))
1239             return IClassFactory_QueryInterface(&class_factories[i].factory.IClassFactory_iface, iid, out);
1240     }
1241
1242     FIXME("%s not available, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(clsid));
1243     return CLASS_E_CLASSNOTAVAILABLE;
1244 }