dlls/xaudio2_7/xapofx.c

   1 /*
   2  * Copyright (c) 2015 Andrew Eikum for CodeWeavers
   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 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define NONAMELESSUNION
  24 #define COBJMACROS
  25
  26 #include "initguid.h"
  27 #include "xaudio_private.h"
  28 #include "xapofx.h"
  29
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(xaudio2);
  33
  34 #ifdef XAPOFX1_VER
  35 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, void *pReserved)
  36 {
  37     TRACE("(%p, %d, %p)\n", hinstDLL, reason, pReserved);
  38
  39     switch (reason)
  40     {
  41     case DLL_WINE_PREATTACH:
  42         return FALSE;  /* prefer native version */
  43     case DLL_PROCESS_ATTACH:
  44         DisableThreadLibraryCalls( hinstDLL );
  45         break;
  46     }
  47     return TRUE;
  48 }
  49 #endif /* XAPOFX1_VER */
  50
  51 typedef struct _VUMeterImpl {
  52     IXAPO IXAPO_iface;
  53     IXAPOParameters IXAPOParameters_iface;
  54
  55     LONG ref;
  56 } VUMeterImpl;
  57
  58 static VUMeterImpl *VUMeterImpl_from_IXAPO(IXAPO *iface)
  59 {
  60     return CONTAINING_RECORD(iface, VUMeterImpl, IXAPO_iface);
  61 }
  62
  63 static VUMeterImpl *VUMeterImpl_from_IXAPOParameters(IXAPOParameters *iface)
  64 {
  65     return CONTAINING_RECORD(iface, VUMeterImpl, IXAPOParameters_iface);
  66 }
  67
  68 static HRESULT WINAPI VUMXAPO_QueryInterface(IXAPO *iface, REFIID riid,
  69         void **ppvObject)
  70 {
  71     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
  72
  73     TRACE("%p, %s, %p\n", This, wine_dbgstr_guid(riid), ppvObject);
  74
  75     if(IsEqualGUID(riid, &IID_IUnknown) ||
  76             IsEqualGUID(riid, &IID_IXAPO) ||
  77             IsEqualGUID(riid, &IID_IXAPO27))
  78         *ppvObject = &This->IXAPO_iface;
  79     else if(IsEqualGUID(riid, &IID_IXAPOParameters))
  80         *ppvObject = &This->IXAPOParameters_iface;
  81     else
  82         *ppvObject = NULL;
  83
  84     if(*ppvObject){
  85         IUnknown_AddRef((IUnknown*)*ppvObject);
  86         return S_OK;
  87     }
  88
  89     return E_NOINTERFACE;
  90 }
  91
  92 static ULONG WINAPI VUMXAPO_AddRef(IXAPO *iface)
  93 {
  94     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
  95     ULONG ref = InterlockedIncrement(&This->ref);
  96     TRACE("(%p)->(): Refcount now %u\n", This, ref);
  97     return ref;
  98 }
  99
 100 static ULONG WINAPI VUMXAPO_Release(IXAPO *iface)
 101 {
 102     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 103     ULONG ref = InterlockedDecrement(&This->ref);
 104
 105     TRACE("(%p)->(): Refcount now %u\n", This, ref);
 106
 107     if(!ref)
 108         HeapFree(GetProcessHeap(), 0, This);
 109
 110     return ref;
 111 }
 112
 113 static HRESULT WINAPI VUMXAPO_GetRegistrationProperties(IXAPO *iface,
 114     XAPO_REGISTRATION_PROPERTIES **props)
 115 {
 116     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 117     TRACE("%p, %p\n", This, props);
 118     /* TODO: check for version == 20 and use XAPO20_REGISTRATION_PROPERTIES */
 119     return E_NOTIMPL;
 120 }
 121
 122 static HRESULT WINAPI VUMXAPO_IsInputFormatSupported(IXAPO *iface,
 123         const WAVEFORMATEX *output_fmt, const WAVEFORMATEX *input_fmt,
 124         WAVEFORMATEX **supported_fmt)
 125 {
 126     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 127     TRACE("%p, %p, %p, %p\n", This, output_fmt, input_fmt, supported_fmt);
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI VUMXAPO_IsOutputFormatSupported(IXAPO *iface,
 132         const WAVEFORMATEX *input_fmt, const WAVEFORMATEX *output_fmt,
 133         WAVEFORMATEX **supported_fmt)
 134 {
 135     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 136     TRACE("%p, %p, %p, %p\n", This, input_fmt, output_fmt, supported_fmt);
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI VUMXAPO_Initialize(IXAPO *iface, const void *data,
 141         UINT32 data_len)
 142 {
 143     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 144     TRACE("%p, %p, %u\n", This, data, data_len);
 145     return E_NOTIMPL;
 146 }
 147
 148 static void WINAPI VUMXAPO_Reset(IXAPO *iface)
 149 {
 150     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 151     TRACE("%p\n", This);
 152 }
 153
 154 static HRESULT WINAPI VUMXAPO_LockForProcess(IXAPO *iface,
 155         UINT32 in_params_count,
 156         const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS *in_params,
 157         UINT32 out_params_count,
 158         const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS *out_params)
 159 {
 160     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 161     TRACE("%p, %u, %p, %u, %p\n", This, in_params_count, in_params,
 162             out_params_count, out_params);
 163     return E_NOTIMPL;
 164 }
 165
 166 static void WINAPI VUMXAPO_UnlockForProcess(IXAPO *iface)
 167 {
 168     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 169     TRACE("%p\n", This);
 170 }
 171
 172 static void WINAPI VUMXAPO_Process(IXAPO *iface, UINT32 in_params_count,
 173         const XAPO_PROCESS_BUFFER_PARAMETERS *in_params,
 174         UINT32 out_params_count,
 175         const XAPO_PROCESS_BUFFER_PARAMETERS *out_params, BOOL enabled)
 176 {
 177     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 178     TRACE("%p, %u, %p, %u, %p, %u\n", This, in_params_count, in_params,
 179             out_params_count, out_params, enabled);
 180 }
 181
 182 static UINT32 WINAPI VUMXAPO_CalcInputFrames(IXAPO *iface, UINT32 output_frames)
 183 {
 184     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 185     TRACE("%p, %u\n", This, output_frames);
 186     return 0;
 187 }
 188
 189 static UINT32 WINAPI VUMXAPO_CalcOutputFrames(IXAPO *iface, UINT32 input_frames)
 190 {
 191     VUMeterImpl *This = VUMeterImpl_from_IXAPO(iface);
 192     TRACE("%p, %u\n", This, input_frames);
 193     return 0;
 194 }
 195
 196 static const IXAPOVtbl VUMXAPO_Vtbl = {
 197     VUMXAPO_QueryInterface,
 198     VUMXAPO_AddRef,
 199     VUMXAPO_Release,
 200     VUMXAPO_GetRegistrationProperties,
 201     VUMXAPO_IsInputFormatSupported,
 202     VUMXAPO_IsOutputFormatSupported,
 203     VUMXAPO_Initialize,
 204     VUMXAPO_Reset,
 205     VUMXAPO_LockForProcess,
 206     VUMXAPO_UnlockForProcess,
 207     VUMXAPO_Process,
 208     VUMXAPO_CalcInputFrames,
 209     VUMXAPO_CalcOutputFrames
 210 };
 211
 212 static HRESULT WINAPI VUMXAPOParams_QueryInterface(IXAPOParameters *iface,
 213         REFIID riid, void **ppvObject)
 214 {
 215     VUMeterImpl *This = VUMeterImpl_from_IXAPOParameters(iface);
 216     return VUMXAPO_QueryInterface(&This->IXAPO_iface, riid, ppvObject);
 217 }
 218
 219 static ULONG WINAPI VUMXAPOParams_AddRef(IXAPOParameters *iface)
 220 {
 221     VUMeterImpl *This = VUMeterImpl_from_IXAPOParameters(iface);
 222     return VUMXAPO_AddRef(&This->IXAPO_iface);
 223 }
 224
 225 static ULONG WINAPI VUMXAPOParams_Release(IXAPOParameters *iface)
 226 {
 227     VUMeterImpl *This = VUMeterImpl_from_IXAPOParameters(iface);
 228     return VUMXAPO_Release(&This->IXAPO_iface);
 229 }
 230
 231 static void WINAPI VUMXAPOParams_SetParameters(IXAPOParameters *iface,
 232         const void *params, UINT32 params_len)
 233 {
 234     VUMeterImpl *This = VUMeterImpl_from_IXAPOParameters(iface);
 235     TRACE("%p, %p, %u\n", This, params, params_len);
 236 }
 237
 238 static void WINAPI VUMXAPOParams_GetParameters(IXAPOParameters *iface,
 239         void *params, UINT32 params_len)
 240 {
 241     VUMeterImpl *This = VUMeterImpl_from_IXAPOParameters(iface);
 242     TRACE("%p, %p, %u\n", This, params, params_len);
 243 }
 244
 245 static const IXAPOParametersVtbl VUMXAPOParameters_Vtbl = {
 246     VUMXAPOParams_QueryInterface,
 247     VUMXAPOParams_AddRef,
 248     VUMXAPOParams_Release,
 249     VUMXAPOParams_SetParameters,
 250     VUMXAPOParams_GetParameters
 251 };
 252
 253 typedef struct _ReverbImpl {
 254     IXAPO IXAPO_iface;
 255     IXAPOParameters IXAPOParameters_iface;
 256
 257     LONG ref;
 258 } ReverbImpl;
 259
 260 static ReverbImpl *ReverbImpl_from_IXAPO(IXAPO *iface)
 261 {
 262     return CONTAINING_RECORD(iface, ReverbImpl, IXAPO_iface);
 263 }
 264
 265 static ReverbImpl *ReverbImpl_from_IXAPOParameters(IXAPOParameters *iface)
 266 {
 267     return CONTAINING_RECORD(iface, ReverbImpl, IXAPOParameters_iface);
 268 }
 269
 270 static HRESULT WINAPI RVBXAPO_QueryInterface(IXAPO *iface, REFIID riid, void **ppvObject)
 271 {
 272     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 273
 274     TRACE("%p, %s, %p\n", This, wine_dbgstr_guid(riid), ppvObject);
 275
 276     if(IsEqualGUID(riid, &IID_IUnknown) ||
 277             IsEqualGUID(riid, &IID_IXAPO) ||
 278             IsEqualGUID(riid, &IID_IXAPO27))
 279         *ppvObject = &This->IXAPO_iface;
 280     else if(IsEqualGUID(riid, &IID_IXAPOParameters))
 281         *ppvObject = &This->IXAPOParameters_iface;
 282     else
 283         *ppvObject = NULL;
 284
 285     if(*ppvObject){
 286         IUnknown_AddRef((IUnknown*)*ppvObject);
 287         return S_OK;
 288     }
 289
 290     return E_NOINTERFACE;
 291 }
 292
 293 static ULONG WINAPI RVBXAPO_AddRef(IXAPO *iface)
 294 {
 295     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 296     ULONG ref = InterlockedIncrement(&This->ref);
 297     TRACE("(%p)->(): Refcount now %u\n", This, ref);
 298     return ref;
 299 }
 300
 301 static ULONG WINAPI RVBXAPO_Release(IXAPO *iface)
 302 {
 303     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 304     ULONG ref = InterlockedDecrement(&This->ref);
 305
 306     TRACE("(%p)->(): Refcount now %u\n", This, ref);
 307
 308     if(!ref)
 309         HeapFree(GetProcessHeap(), 0, This);
 310
 311     return ref;
 312 }
 313
 314 static HRESULT WINAPI RVBXAPO_GetRegistrationProperties(IXAPO *iface,
 315     XAPO_REGISTRATION_PROPERTIES **props)
 316 {
 317     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 318     TRACE("%p, %p\n", This, props);
 319     /* TODO: check for version == 20 and use XAPO20_REGISTRATION_PROPERTIES */
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI RVBXAPO_IsInputFormatSupported(IXAPO *iface,
 324         const WAVEFORMATEX *output_fmt, const WAVEFORMATEX *input_fmt,
 325         WAVEFORMATEX **supported_fmt)
 326 {
 327     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 328     TRACE("%p, %p, %p, %p\n", This, output_fmt, input_fmt, supported_fmt);
 329     return E_NOTIMPL;
 330 }
 331
 332 static HRESULT WINAPI RVBXAPO_IsOutputFormatSupported(IXAPO *iface,
 333         const WAVEFORMATEX *input_fmt, const WAVEFORMATEX *output_fmt,
 334         WAVEFORMATEX **supported_fmt)
 335 {
 336     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 337     TRACE("%p, %p, %p, %p\n", This, input_fmt, output_fmt, supported_fmt);
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI RVBXAPO_Initialize(IXAPO *iface, const void *data,
 342         UINT32 data_len)
 343 {
 344     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 345     TRACE("%p, %p, %u\n", This, data, data_len);
 346     return E_NOTIMPL;
 347 }
 348
 349 static void WINAPI RVBXAPO_Reset(IXAPO *iface)
 350 {
 351     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 352     TRACE("%p\n", This);
 353 }
 354
 355 static HRESULT WINAPI RVBXAPO_LockForProcess(IXAPO *iface, UINT32 in_params_count,
 356         const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS *in_params,
 357         UINT32 out_params_count,
 358         const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS *out_params)
 359 {
 360     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 361     TRACE("%p, %u, %p, %u, %p\n", This, in_params_count, in_params,
 362             out_params_count, out_params);
 363     return E_NOTIMPL;
 364 }
 365
 366 static void WINAPI RVBXAPO_UnlockForProcess(IXAPO *iface)
 367 {
 368     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 369     TRACE("%p\n", This);
 370 }
 371
 372 static void WINAPI RVBXAPO_Process(IXAPO *iface, UINT32 in_params_count,
 373         const XAPO_PROCESS_BUFFER_PARAMETERS *in_params,
 374         UINT32 out_params_count,
 375         const XAPO_PROCESS_BUFFER_PARAMETERS *out_params, BOOL enabled)
 376 {
 377     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 378     TRACE("%p, %u, %p, %u, %p, %u\n", This, in_params_count, in_params,
 379             out_params_count, out_params, enabled);
 380 }
 381
 382 static UINT32 WINAPI RVBXAPO_CalcInputFrames(IXAPO *iface, UINT32 output_frames)
 383 {
 384     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 385     TRACE("%p, %u\n", This, output_frames);
 386     return 0;
 387 }
 388
 389 static UINT32 WINAPI RVBXAPO_CalcOutputFrames(IXAPO *iface, UINT32 input_frames)
 390 {
 391     ReverbImpl *This = ReverbImpl_from_IXAPO(iface);
 392     TRACE("%p, %u\n", This, input_frames);
 393     return 0;
 394 }
 395
 396 static const IXAPOVtbl RVBXAPO_Vtbl = {
 397     RVBXAPO_QueryInterface,
 398     RVBXAPO_AddRef,
 399     RVBXAPO_Release,
 400     RVBXAPO_GetRegistrationProperties,
 401     RVBXAPO_IsInputFormatSupported,
 402     RVBXAPO_IsOutputFormatSupported,
 403     RVBXAPO_Initialize,
 404     RVBXAPO_Reset,
 405     RVBXAPO_LockForProcess,
 406     RVBXAPO_UnlockForProcess,
 407     RVBXAPO_Process,
 408     RVBXAPO_CalcInputFrames,
 409     RVBXAPO_CalcOutputFrames
 410 };
 411
 412 static HRESULT WINAPI RVBXAPOParams_QueryInterface(IXAPOParameters *iface,
 413         REFIID riid, void **ppvObject)
 414 {
 415     ReverbImpl *This = ReverbImpl_from_IXAPOParameters(iface);
 416     return RVBXAPO_QueryInterface(&This->IXAPO_iface, riid, ppvObject);
 417 }
 418
 419 static ULONG WINAPI RVBXAPOParams_AddRef(IXAPOParameters *iface)
 420 {
 421     ReverbImpl *This = ReverbImpl_from_IXAPOParameters(iface);
 422     return RVBXAPO_AddRef(&This->IXAPO_iface);
 423 }
 424
 425 static ULONG WINAPI RVBXAPOParams_Release(IXAPOParameters *iface)
 426 {
 427     ReverbImpl *This = ReverbImpl_from_IXAPOParameters(iface);
 428     return RVBXAPO_Release(&This->IXAPO_iface);
 429 }
 430
 431 static void WINAPI RVBXAPOParams_SetParameters(IXAPOParameters *iface,
 432         const void *params, UINT32 params_len)
 433 {
 434     ReverbImpl *This = ReverbImpl_from_IXAPOParameters(iface);
 435     TRACE("%p, %p, %u\n", This, params, params_len);
 436 }
 437
 438 static void WINAPI RVBXAPOParams_GetParameters(IXAPOParameters *iface, void *params,
 439         UINT32 params_len)
 440 {
 441     ReverbImpl *This = ReverbImpl_from_IXAPOParameters(iface);
 442     TRACE("%p, %p, %u\n", This, params, params_len);
 443 }
 444
 445 static const IXAPOParametersVtbl RVBXAPOParameters_Vtbl = {
 446     RVBXAPOParams_QueryInterface,
 447     RVBXAPOParams_AddRef,
 448     RVBXAPOParams_Release,
 449     RVBXAPOParams_SetParameters,
 450     RVBXAPOParams_GetParameters
 451 };
 452
 453 typedef struct _EQImpl {
 454     IXAPO IXAPO_iface;
 455     IXAPOParameters IXAPOParameters_iface;
 456
 457     LONG ref;
 458 } EQImpl;
 459
 460 static EQImpl *EQImpl_from_IXAPO(IXAPO *iface)
 461 {
 462     return CONTAINING_RECORD(iface, EQImpl, IXAPO_iface);
 463 }
 464
 465 static EQImpl *EQImpl_from_IXAPOParameters(IXAPOParameters *iface)
 466 {
 467     return CONTAINING_RECORD(iface, EQImpl, IXAPOParameters_iface);
 468 }
 469
 470 static HRESULT WINAPI EQXAPO_QueryInterface(IXAPO *iface, REFIID riid, void **ppvObject)
 471 {
 472     EQImpl *This = EQImpl_from_IXAPO(iface);
 473
 474     TRACE("%p, %s, %p\n", This, wine_dbgstr_guid(riid), ppvObject);
 475
 476     if(IsEqualGUID(riid, &IID_IUnknown) ||
 477             IsEqualGUID(riid, &IID_IXAPO) ||
 478             IsEqualGUID(riid, &IID_IXAPO27))
 479         *ppvObject = &This->IXAPO_iface;
 480     else if(IsEqualGUID(riid, &IID_IXAPOParameters))
 481         *ppvObject = &This->IXAPOParameters_iface;
 482     else
 483         *ppvObject = NULL;
 484
 485     if(*ppvObject){
 486         IUnknown_AddRef((IUnknown*)*ppvObject);
 487         return S_OK;
 488     }
 489
 490     return E_NOINTERFACE;
 491 }
 492
 493 static ULONG WINAPI EQXAPO_AddRef(IXAPO *iface)
 494 {
 495     EQImpl *This = EQImpl_from_IXAPO(iface);
 496     ULONG ref = InterlockedIncrement(&This->ref);
 497     TRACE("(%p)->(): Refcount now %u\n", This, ref);
 498     return ref;
 499 }
 500
 501 static ULONG WINAPI EQXAPO_Release(IXAPO *iface)
 502 {
 503     EQImpl *This = EQImpl_from_IXAPO(iface);
 504     ULONG ref = InterlockedDecrement(&This->ref);
 505
 506     TRACE("(%p)->(): Refcount now %u\n", This, ref);
 507
 508     if(!ref)
 509         HeapFree(GetProcessHeap(), 0, This);
 510
 511     return ref;
 512 }
 513
 514 static HRESULT WINAPI EQXAPO_GetRegistrationProperties(IXAPO *iface,
 515     XAPO_REGISTRATION_PROPERTIES **props)
 516 {
 517     EQImpl *This = EQImpl_from_IXAPO(iface);
 518     TRACE("%p, %p\n", This, props);
 519     /* TODO: check for version == 20 and use XAPO20_REGISTRATION_PROPERTIES */
 520     return E_NOTIMPL;
 521 }
 522
 523 static HRESULT WINAPI EQXAPO_IsInputFormatSupported(IXAPO *iface,
 524         const WAVEFORMATEX *output_fmt, const WAVEFORMATEX *input_fmt,
 525         WAVEFORMATEX **supported_fmt)
 526 {
 527     EQImpl *This = EQImpl_from_IXAPO(iface);
 528     TRACE("%p, %p, %p, %p\n", This, output_fmt, input_fmt, supported_fmt);
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI EQXAPO_IsOutputFormatSupported(IXAPO *iface,
 533         const WAVEFORMATEX *input_fmt, const WAVEFORMATEX *output_fmt,
 534         WAVEFORMATEX **supported_fmt)
 535 {
 536     EQImpl *This = EQImpl_from_IXAPO(iface);
 537     TRACE("%p, %p, %p, %p\n", This, input_fmt, output_fmt, supported_fmt);
 538     return E_NOTIMPL;
 539 }
 540
 541 static HRESULT WINAPI EQXAPO_Initialize(IXAPO *iface, const void *data,
 542         UINT32 data_len)
 543 {
 544     EQImpl *This = EQImpl_from_IXAPO(iface);
 545     TRACE("%p, %p, %u\n", This, data, data_len);
 546     return E_NOTIMPL;
 547 }
 548
 549 static void WINAPI EQXAPO_Reset(IXAPO *iface)
 550 {
 551     EQImpl *This = EQImpl_from_IXAPO(iface);
 552     TRACE("%p\n", This);
 553 }
 554
 555 static HRESULT WINAPI EQXAPO_LockForProcess(IXAPO *iface, UINT32 in_params_count,
 556         const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS *in_params,
 557         UINT32 out_params_count,
 558         const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS *out_params)
 559 {
 560     EQImpl *This = EQImpl_from_IXAPO(iface);
 561     TRACE("%p, %u, %p, %u, %p\n", This, in_params_count, in_params,
 562             out_params_count, out_params);
 563     return E_NOTIMPL;
 564 }
 565
 566 static void WINAPI EQXAPO_UnlockForProcess(IXAPO *iface)
 567 {
 568     EQImpl *This = EQImpl_from_IXAPO(iface);
 569     TRACE("%p\n", This);
 570 }
 571
 572 static void WINAPI EQXAPO_Process(IXAPO *iface, UINT32 in_params_count,
 573         const XAPO_PROCESS_BUFFER_PARAMETERS *in_params,
 574         UINT32 out_params_count,
 575         const XAPO_PROCESS_BUFFER_PARAMETERS *out_params, BOOL enabled)
 576 {
 577     EQImpl *This = EQImpl_from_IXAPO(iface);
 578     TRACE("%p, %u, %p, %u, %p, %u\n", This, in_params_count, in_params,
 579             out_params_count, out_params, enabled);
 580 }
 581
 582 static UINT32 WINAPI EQXAPO_CalcInputFrames(IXAPO *iface, UINT32 output_frames)
 583 {
 584     EQImpl *This = EQImpl_from_IXAPO(iface);
 585     TRACE("%p, %u\n", This, output_frames);
 586     return 0;
 587 }
 588
 589 static UINT32 WINAPI EQXAPO_CalcOutputFrames(IXAPO *iface, UINT32 input_frames)
 590 {
 591     EQImpl *This = EQImpl_from_IXAPO(iface);
 592     TRACE("%p, %u\n", This, input_frames);
 593     return 0;
 594 }
 595
 596 static const IXAPOVtbl EQXAPO_Vtbl = {
 597     EQXAPO_QueryInterface,
 598     EQXAPO_AddRef,
 599     EQXAPO_Release,
 600     EQXAPO_GetRegistrationProperties,
 601     EQXAPO_IsInputFormatSupported,
 602     EQXAPO_IsOutputFormatSupported,
 603     EQXAPO_Initialize,
 604     EQXAPO_Reset,
 605     EQXAPO_LockForProcess,
 606     EQXAPO_UnlockForProcess,
 607     EQXAPO_Process,
 608     EQXAPO_CalcInputFrames,
 609     EQXAPO_CalcOutputFrames
 610 };
 611
 612 static HRESULT WINAPI EQXAPOParams_QueryInterface(IXAPOParameters *iface,
 613         REFIID riid, void **ppvObject)
 614 {
 615     EQImpl *This = EQImpl_from_IXAPOParameters(iface);
 616     return EQXAPO_QueryInterface(&This->IXAPO_iface, riid, ppvObject);
 617 }
 618
 619 static ULONG WINAPI EQXAPOParams_AddRef(IXAPOParameters *iface)
 620 {
 621     EQImpl *This = EQImpl_from_IXAPOParameters(iface);
 622     return EQXAPO_AddRef(&This->IXAPO_iface);
 623 }
 624
 625 static ULONG WINAPI EQXAPOParams_Release(IXAPOParameters *iface)
 626 {
 627     EQImpl *This = EQImpl_from_IXAPOParameters(iface);
 628     return EQXAPO_Release(&This->IXAPO_iface);
 629 }
 630
 631 static void WINAPI EQXAPOParams_SetParameters(IXAPOParameters *iface,
 632         const void *params, UINT32 params_len)
 633 {
 634     EQImpl *This = EQImpl_from_IXAPOParameters(iface);
 635     TRACE("%p, %p, %u\n", This, params, params_len);
 636 }
 637
 638 static void WINAPI EQXAPOParams_GetParameters(IXAPOParameters *iface, void *params,
 639         UINT32 params_len)
 640 {
 641     EQImpl *This = EQImpl_from_IXAPOParameters(iface);
 642     TRACE("%p, %p, %u\n", This, params, params_len);
 643 }
 644
 645 static const IXAPOParametersVtbl EQXAPOParameters_Vtbl = {
 646     EQXAPOParams_QueryInterface,
 647     EQXAPOParams_AddRef,
 648     EQXAPOParams_Release,
 649     EQXAPOParams_SetParameters,
 650     EQXAPOParams_GetParameters
 651 };
 652
 653 struct xapo_cf {
 654     IClassFactory IClassFactory_iface;
 655     LONG ref;
 656     const CLSID *class;
 657 };
 658
 659 static struct xapo_cf *xapo_impl_from_IClassFactory(IClassFactory *iface)
 660 {
 661     return CONTAINING_RECORD(iface, struct xapo_cf, IClassFactory_iface);
 662 }
 663
 664 static HRESULT WINAPI xapocf_QueryInterface(IClassFactory *iface, REFIID riid, void **ppobj)
 665 {
 666     if(IsEqualGUID(riid, &IID_IUnknown)
 667             || IsEqualGUID(riid, &IID_IClassFactory))
 668     {
 669         IClassFactory_AddRef(iface);
 670         *ppobj = iface;
 671         return S_OK;
 672     }
 673
 674     *ppobj = NULL;
 675     WARN("(%p)->(%s, %p): interface not found\n", iface, debugstr_guid(riid), ppobj);
 676     return E_NOINTERFACE;
 677 }
 678
 679 static ULONG WINAPI xapocf_AddRef(IClassFactory *iface)
 680 {
 681     struct xapo_cf *This = xapo_impl_from_IClassFactory(iface);
 682     ULONG ref = InterlockedIncrement(&This->ref);
 683     TRACE("(%p)->(): Refcount now %u\n", This, ref);
 684     return ref;
 685 }
 686
 687 static ULONG WINAPI xapocf_Release(IClassFactory *iface)
 688 {
 689     struct xapo_cf *This = xapo_impl_from_IClassFactory(iface);
 690     ULONG ref = InterlockedDecrement(&This->ref);
 691     TRACE("(%p)->(): Refcount now %u\n", This, ref);
 692     if (!ref)
 693         HeapFree(GetProcessHeap(), 0, This);
 694     return ref;
 695 }
 696
 697 static HRESULT WINAPI xapocf_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
 698         REFIID riid, void **ppobj)
 699 {
 700     struct xapo_cf *This = xapo_impl_from_IClassFactory(iface);
 701     HRESULT hr;
 702
 703     TRACE("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
 704
 705     *ppobj = NULL;
 706
 707     if(pOuter)
 708         return CLASS_E_NOAGGREGATION;
 709
 710     if(IsEqualGUID(This->class, &CLSID_AudioVolumeMeter27)){
 711         VUMeterImpl *object;
 712
 713         object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 714         if(!object)
 715             return E_OUTOFMEMORY;
 716
 717         object->IXAPO_iface.lpVtbl = &VUMXAPO_Vtbl;
 718         object->IXAPOParameters_iface.lpVtbl = &VUMXAPOParameters_Vtbl;
 719
 720         hr = IXAPO_QueryInterface(&object->IXAPO_iface, riid, ppobj);
 721         if(FAILED(hr)){
 722             HeapFree(GetProcessHeap(), 0, object);
 723             return hr;
 724         }
 725     }else if(IsEqualGUID(This->class, &CLSID_FXReverb)){
 726         ReverbImpl *object;
 727
 728         object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 729         if(!object)
 730             return E_OUTOFMEMORY;
 731
 732         object->IXAPO_iface.lpVtbl = &RVBXAPO_Vtbl;
 733         object->IXAPOParameters_iface.lpVtbl = &RVBXAPOParameters_Vtbl;
 734
 735         hr = IXAPO_QueryInterface(&object->IXAPO_iface, riid, ppobj);
 736         if(FAILED(hr)){
 737             HeapFree(GetProcessHeap(), 0, object);
 738             return hr;
 739         }
 740     }else if(IsEqualGUID(This->class, &CLSID_FXEQ)){
 741         EQImpl *object;
 742
 743         object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 744         if(!object)
 745             return E_OUTOFMEMORY;
 746
 747         object->IXAPO_iface.lpVtbl = &EQXAPO_Vtbl;
 748         object->IXAPOParameters_iface.lpVtbl = &EQXAPOParameters_Vtbl;
 749
 750         hr = IXAPO_QueryInterface(&object->IXAPO_iface, riid, ppobj);
 751         if(FAILED(hr)){
 752             HeapFree(GetProcessHeap(), 0, object);
 753             return hr;
 754         }
 755     }else
 756         /* TODO FXECHO, FXMasteringLimiter, */
 757         return E_INVALIDARG;
 758
 759     return S_OK;
 760 }
 761
 762 static HRESULT WINAPI xapocf_LockServer(IClassFactory *iface, BOOL dolock)
 763 {
 764     struct xapo_cf *This = xapo_impl_from_IClassFactory(iface);
 765     FIXME("(%p)->(%d): stub!\n", This, dolock);
 766     return S_OK;
 767 }
 768
 769 static const IClassFactoryVtbl xapo_Vtbl =
 770 {
 771     xapocf_QueryInterface,
 772     xapocf_AddRef,
 773     xapocf_Release,
 774     xapocf_CreateInstance,
 775     xapocf_LockServer
 776 };
 777
 778 HRESULT make_xapo_factory(REFCLSID clsid, REFIID riid, void **ppv)
 779 {
 780     HRESULT hr;
 781     struct xapo_cf *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(struct xapo_cf));
 782     ret->IClassFactory_iface.lpVtbl = &xapo_Vtbl;
 783     ret->class = clsid;
 784     ret->ref = 0;
 785     hr = IClassFactory_QueryInterface(&ret->IClassFactory_iface, riid, ppv);
 786     if(FAILED(hr))
 787         HeapFree(GetProcessHeap(), 0, ret);
 788     return hr;
 789 }
 790
 791 #if XAUDIO2_VER >= 8
 792 HRESULT WINAPI CreateAudioVolumeMeter(IUnknown **out)
 793 {
 794     IClassFactory *cf;
 795     HRESULT hr;
 796
 797     hr = make_xapo_factory(&CLSID_AudioVolumeMeter27, &IID_IClassFactory, (void**)&cf);
 798     if(FAILED(hr))
 799         return hr;
 800
 801     hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)out);
 802
 803     IClassFactory_Release(cf);
 804
 805     return hr;
 806 }
 807
 808 HRESULT WINAPI CreateAudioReverb(IUnknown **out)
 809 {
 810     IClassFactory *cf;
 811     HRESULT hr;
 812
 813     hr = make_xapo_factory(&CLSID_FXReverb, &IID_IClassFactory, (void**)&cf);
 814     if(FAILED(hr))
 815         return hr;
 816
 817     hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)out);
 818
 819     IClassFactory_Release(cf);
 820
 821     return hr;
 822 }
 823
 824 HRESULT CDECL CreateFX(REFCLSID clsid, IUnknown **out, void *initdata, UINT32 initdata_bytes)
 825 {
 826     HRESULT hr;
 827     IUnknown *obj;
 828     const GUID *class = NULL;
 829     IClassFactory *cf;
 830
 831     *out = NULL;
 832
 833     if(IsEqualGUID(clsid, &CLSID_FXReverb27) ||
 834             IsEqualGUID(clsid, &CLSID_FXReverb))
 835         class = &CLSID_FXReverb;
 836     else if(IsEqualGUID(clsid, &CLSID_FXEQ27) ||
 837             IsEqualGUID(clsid, &CLSID_FXEQ))
 838         class = &CLSID_FXEQ;
 839
 840     if(class){
 841         hr = make_xapo_factory(class, &IID_IClassFactory, (void**)&cf);
 842         if(FAILED(hr))
 843             return hr;
 844
 845         hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)&obj);
 846         IClassFactory_Release(cf);
 847         if(FAILED(hr))
 848             return hr;
 849     }else{
 850         hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&obj);
 851         if(FAILED(hr)){
 852             WARN("CoCreateInstance failed: %08x\n", hr);
 853             return hr;
 854         }
 855     }
 856
 857     if(initdata && initdata_bytes > 0){
 858         IXAPO *xapo;
 859
 860         hr = IUnknown_QueryInterface(obj, &IID_IXAPO, (void**)&xapo);
 861         if(SUCCEEDED(hr)){
 862             hr = IXAPO_Initialize(xapo, initdata, initdata_bytes);
 863
 864             IXAPO_Release(xapo);
 865
 866             if(FAILED(hr)){
 867                 WARN("Initialize failed: %08x\n", hr);
 868                 IUnknown_Release(obj);
 869                 return hr;
 870             }
 871         }
 872     }
 873
 874     *out = obj;
 875
 876     return S_OK;
 877 }
 878 #endif /* XAUDIO2_VER >= 8 */
 879
 880 #ifdef XAPOFX1_VER
 881 HRESULT CDECL CreateFX(REFCLSID clsid, IUnknown **out)
 882 {
 883     HRESULT hr;
 884     IUnknown *obj;
 885     const GUID *class = NULL;
 886     IClassFactory *cf;
 887
 888     TRACE("%s %p\n", debugstr_guid(clsid), out);
 889
 890     *out = NULL;
 891
 892     if(IsEqualGUID(clsid, &CLSID_FXReverb27) ||
 893             IsEqualGUID(clsid, &CLSID_FXReverb))
 894         class = &CLSID_FXReverb;
 895     else if(IsEqualGUID(clsid, &CLSID_FXEQ27) ||
 896             IsEqualGUID(clsid, &CLSID_FXEQ))
 897         class = &CLSID_FXEQ;
 898     /* TODO FXECHO, FXMasteringLimiter, */
 899
 900     if(class){
 901         hr = make_xapo_factory(class, &IID_IClassFactory, (void**)&cf);
 902         if(FAILED(hr))
 903             return hr;
 904
 905         hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)&obj);
 906         IClassFactory_Release(cf);
 907         if(FAILED(hr))
 908             return hr;
 909     }else{
 910         hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&obj);
 911         if(FAILED(hr)){
 912             WARN("CoCreateInstance failed: %08x\n", hr);
 913             return hr;
 914         }
 915     }
 916
 917     *out = obj;
 918
 919     return S_OK;
 920 }
 921 #endif /* XAPOFX1_VER */