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