dlls/xactengine3_7/xact_dll.c

   1 /*
   2  * Copyright (c) 2018 Ethan Lee 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 <stdarg.h>
  20 #include <FACT.h>
  21
  22 #define NONAMELESSUNION
  23 #define COBJMACROS
  24 #include "objbase.h"
  25
  26 #if XACT3_VER < 0x0300
  27 #include "xact2wb.h"
  28 #include "initguid.h"
  29 #include "xact.h"
  30 #else
  31 #include "xact3wb.h"
  32 #include "xaudio2.h"
  33 #include "initguid.h"
  34 #include "xact3.h"
  35 #endif
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(xact3);
  39
  40 #if XACT3_VER < 0x0300
  41 #define IID_IXACT3Engine IID_IXACTEngine
  42 #define IXACT3Cue IXACTCue
  43 #define IXACT3CueVtbl IXACTCueVtbl
  44 #define IXACT3Engine IXACTEngine
  45 #define IXACT3EngineVtbl IXACTEngineVtbl
  46 #define IXACT3Engine_QueryInterface IXACTEngine_QueryInterface
  47 #define IXACT3SoundBank IXACTSoundBank
  48 #define IXACT3SoundBankVtbl IXACTSoundBankVtbl
  49 #define IXACT3Wave IXACTWave
  50 #define IXACT3WaveVtbl IXACTWaveVtbl
  51 #define IXACT3WaveBank IXACTWaveBank
  52 #define IXACT3WaveBankVtbl IXACTWaveBankVtbl
  53 #endif
  54
  55 typedef struct _XACT3CueImpl {
  56     IXACT3Cue IXACT3Cue_iface;
  57     FACTCue *fact_cue;
  58 } XACT3CueImpl;
  59
  60 static inline XACT3CueImpl *impl_from_IXACT3Cue(IXACT3Cue *iface)
  61 {
  62     return CONTAINING_RECORD(iface, XACT3CueImpl, IXACT3Cue_iface);
  63 }
  64
  65 static HRESULT WINAPI IXACT3CueImpl_Play(IXACT3Cue *iface)
  66 {
  67     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
  68
  69     TRACE("(%p)\n", iface);
  70
  71     return FACTCue_Play(This->fact_cue);
  72 }
  73
  74 static HRESULT WINAPI IXACT3CueImpl_Stop(IXACT3Cue *iface, DWORD dwFlags)
  75 {
  76     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
  77
  78     TRACE("(%p)->(%lu)\n", iface, dwFlags);
  79
  80     return FACTCue_Stop(This->fact_cue, dwFlags);
  81 }
  82
  83 static HRESULT WINAPI IXACT3CueImpl_GetState(IXACT3Cue *iface, DWORD *pdwState)
  84 {
  85     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
  86
  87     TRACE("(%p)->(%p)\n", iface, pdwState);
  88
  89     return FACTCue_GetState(This->fact_cue, (uint32_t *)pdwState);
  90 }
  91
  92 static HRESULT WINAPI IXACT3CueImpl_Destroy(IXACT3Cue *iface)
  93 {
  94     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
  95     UINT ret;
  96
  97     TRACE("(%p)\n", iface);
  98
  99     ret = FACTCue_Destroy(This->fact_cue);
 100     if (ret != 0)
 101         WARN("FACTCue_Destroy returned %d\n", ret);
 102     HeapFree(GetProcessHeap(), 0, This);
 103     return S_OK;
 104 }
 105
 106 #if XACT3_VER < 0x0300
 107
 108 static HRESULT WINAPI IXACT3CueImpl_GetChannelMap(IXACT3Cue *iface,
 109         XACTCHANNELMAP *map, DWORD size, DWORD *needed_size)
 110 {
 111     FIXME("(%p)->(%p, %lu, %p)\n", iface, map, size, needed_size);
 112
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI IXACT3CueImpl_SetChannelMap(IXACT3Cue *iface, XACTCHANNELMAP *map)
 117 {
 118     FIXME("(%p)->(%p)\n", iface, map);
 119
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI IXACT3CueImpl_GetChannelVolume(IXACT3Cue *iface, XACTCHANNELVOLUME *volume)
 124 {
 125     FIXME("(%p)->(%p)\n", iface, volume);
 126
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI IXACT3CueImpl_SetChannelVolume(IXACT3Cue *iface, XACTCHANNELVOLUME *volume)
 131 {
 132     FIXME("(%p)->(%p)\n", iface, volume);
 133
 134     return E_NOTIMPL;
 135 }
 136
 137 #endif
 138
 139 static HRESULT WINAPI IXACT3CueImpl_SetMatrixCoefficients(IXACT3Cue *iface,
 140         UINT32 uSrcChannelCount, UINT32 uDstChannelCount,
 141         float *pMatrixCoefficients)
 142 {
 143     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 144
 145     TRACE("(%p)->(%u, %u, %p)\n", iface, uSrcChannelCount, uDstChannelCount,
 146             pMatrixCoefficients);
 147
 148     return FACTCue_SetMatrixCoefficients(This->fact_cue, uSrcChannelCount,
 149         uDstChannelCount, pMatrixCoefficients);
 150 }
 151
 152 static XACTVARIABLEINDEX WINAPI IXACT3CueImpl_GetVariableIndex(IXACT3Cue *iface,
 153         PCSTR szFriendlyName)
 154 {
 155     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 156
 157     TRACE("(%p)->(%s)\n", iface, szFriendlyName);
 158
 159     return FACTCue_GetVariableIndex(This->fact_cue, szFriendlyName);
 160 }
 161
 162 static HRESULT WINAPI IXACT3CueImpl_SetVariable(IXACT3Cue *iface,
 163         XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue)
 164 {
 165     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 166
 167     TRACE("(%p)->(%u, %f)\n", iface, nIndex, nValue);
 168
 169     return FACTCue_SetVariable(This->fact_cue, nIndex, nValue);
 170 }
 171
 172 static HRESULT WINAPI IXACT3CueImpl_GetVariable(IXACT3Cue *iface,
 173         XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE *nValue)
 174 {
 175     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 176
 177     TRACE("(%p)->(%u, %p)\n", iface, nIndex, nValue);
 178
 179     return FACTCue_GetVariable(This->fact_cue, nIndex, nValue);
 180 }
 181
 182 static HRESULT WINAPI IXACT3CueImpl_Pause(IXACT3Cue *iface, BOOL fPause)
 183 {
 184     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 185
 186     TRACE("(%p)->(%u)\n", iface, fPause);
 187
 188     return FACTCue_Pause(This->fact_cue, fPause);
 189 }
 190
 191 #if XACT3_VER >= 0x0205
 192 static HRESULT WINAPI IXACT3CueImpl_GetProperties(IXACT3Cue *iface,
 193         XACT_CUE_INSTANCE_PROPERTIES **ppProperties)
 194 {
 195     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 196     FACTCueInstanceProperties *fProps;
 197     HRESULT hr;
 198
 199     TRACE("(%p)->(%p)\n", iface, ppProperties);
 200
 201     hr = FACTCue_GetProperties(This->fact_cue, &fProps);
 202     if(FAILED(hr))
 203         return hr;
 204
 205     *ppProperties = (XACT_CUE_INSTANCE_PROPERTIES*) fProps;
 206     return hr;
 207 }
 208 #endif
 209
 210 #if XACT3_VER >= 0x0300
 211 static HRESULT WINAPI IXACT3CueImpl_SetOutputVoices(IXACT3Cue *iface,
 212         const XAUDIO2_VOICE_SENDS *pSendList)
 213 {
 214     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 215     FIXME("(%p)->(%p): stub!\n", This, pSendList);
 216     return S_OK;
 217 }
 218
 219 static HRESULT WINAPI IXACT3CueImpl_SetOutputVoiceMatrix(IXACT3Cue *iface,
 220         IXAudio2Voice *pDestinationVoice, UINT32 SourceChannels,
 221         UINT32 DestinationChannels, const float *pLevelMatrix)
 222 {
 223     XACT3CueImpl *This = impl_from_IXACT3Cue(iface);
 224     FIXME("(%p)->(%p %u %u %p): stub!\n", This, pDestinationVoice, SourceChannels,
 225             DestinationChannels, pLevelMatrix);
 226     return S_OK;
 227 }
 228 #endif
 229
 230 static const IXACT3CueVtbl XACT3Cue_Vtbl =
 231 {
 232     IXACT3CueImpl_Play,
 233     IXACT3CueImpl_Stop,
 234     IXACT3CueImpl_GetState,
 235     IXACT3CueImpl_Destroy,
 236 #if XACT3_VER < 0x0300
 237     IXACT3CueImpl_GetChannelMap,
 238     IXACT3CueImpl_SetChannelMap,
 239     IXACT3CueImpl_GetChannelVolume,
 240     IXACT3CueImpl_SetChannelVolume,
 241 #endif
 242     IXACT3CueImpl_SetMatrixCoefficients,
 243     IXACT3CueImpl_GetVariableIndex,
 244     IXACT3CueImpl_SetVariable,
 245     IXACT3CueImpl_GetVariable,
 246     IXACT3CueImpl_Pause,
 247 #if XACT3_VER >= 0x0205
 248     IXACT3CueImpl_GetProperties,
 249 #endif
 250 #if XACT3_VER >= 0x0300
 251     IXACT3CueImpl_SetOutputVoices,
 252     IXACT3CueImpl_SetOutputVoiceMatrix
 253 #endif
 254 };
 255
 256 typedef struct _XACT3SoundBankImpl {
 257     IXACT3SoundBank IXACT3SoundBank_iface;
 258
 259     FACTSoundBank *fact_soundbank;
 260 } XACT3SoundBankImpl;
 261
 262 static inline XACT3SoundBankImpl *impl_from_IXACT3SoundBank(IXACT3SoundBank *iface)
 263 {
 264     return CONTAINING_RECORD(iface, XACT3SoundBankImpl, IXACT3SoundBank_iface);
 265 }
 266
 267 static XACTINDEX WINAPI IXACT3SoundBankImpl_GetCueIndex(IXACT3SoundBank *iface,
 268         PCSTR szFriendlyName)
 269 {
 270     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 271
 272     TRACE("(%p)->(%s)\n", This, szFriendlyName);
 273
 274     return FACTSoundBank_GetCueIndex(This->fact_soundbank, szFriendlyName);
 275 }
 276
 277 #if XACT3_VER >= 0x0205
 278 static HRESULT WINAPI IXACT3SoundBankImpl_GetNumCues(IXACT3SoundBank *iface,
 279         XACTINDEX *pnNumCues)
 280 {
 281     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 282
 283     TRACE("(%p)->(%p)\n", This, pnNumCues);
 284
 285     return FACTSoundBank_GetNumCues(This->fact_soundbank, pnNumCues);
 286 }
 287
 288 static HRESULT WINAPI IXACT3SoundBankImpl_GetCueProperties(IXACT3SoundBank *iface,
 289         XACTINDEX nCueIndex, XACT_CUE_PROPERTIES *pProperties)
 290 {
 291     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 292
 293     TRACE("(%p)->(%u, %p)\n", This, nCueIndex, pProperties);
 294
 295     return FACTSoundBank_GetCueProperties(This->fact_soundbank, nCueIndex,
 296             (FACTCueProperties*) pProperties);
 297 }
 298 #endif
 299
 300 static HRESULT WINAPI IXACT3SoundBankImpl_Prepare(IXACT3SoundBank *iface,
 301         XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset,
 302         IXACT3Cue** ppCue)
 303 {
 304     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 305     XACT3CueImpl *cue;
 306     FACTCue *fcue;
 307     UINT ret;
 308
 309     TRACE("(%p)->(%u, 0x%lx, %lu, %p)\n", This, nCueIndex, dwFlags, timeOffset,
 310             ppCue);
 311
 312     ret = FACTSoundBank_Prepare(This->fact_soundbank, nCueIndex, dwFlags,
 313             timeOffset, &fcue);
 314     if(ret != 0)
 315     {
 316         ERR("Failed to CreateCue: %d\n", ret);
 317         return E_FAIL;
 318     }
 319
 320     cue = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cue));
 321     if (!cue)
 322     {
 323         FACTCue_Destroy(fcue);
 324         ERR("Failed to allocate XACT3CueImpl!\n");
 325         return E_OUTOFMEMORY;
 326     }
 327
 328     cue->IXACT3Cue_iface.lpVtbl = &XACT3Cue_Vtbl;
 329     cue->fact_cue = fcue;
 330     *ppCue = &cue->IXACT3Cue_iface;
 331
 332     TRACE("Created Cue: %p\n", cue);
 333
 334     return S_OK;
 335 }
 336
 337 static HRESULT WINAPI IXACT3SoundBankImpl_Play(IXACT3SoundBank *iface,
 338         XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset,
 339         IXACT3Cue** ppCue)
 340 {
 341     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 342     XACT3CueImpl *cue;
 343     FACTCue *fcue;
 344     HRESULT hr;
 345
 346     TRACE("(%p)->(%u, 0x%lx, %lu, %p)\n", This, nCueIndex, dwFlags, timeOffset,
 347             ppCue);
 348
 349     /* If the application doesn't want a handle, don't generate one at all.
 350      * Let the engine handle that memory instead.
 351      * -flibit
 352      */
 353     if (ppCue == NULL){
 354         hr = FACTSoundBank_Play(This->fact_soundbank, nCueIndex, dwFlags,
 355                 timeOffset, NULL);
 356     }else{
 357         hr = FACTSoundBank_Play(This->fact_soundbank, nCueIndex, dwFlags,
 358                 timeOffset, &fcue);
 359         if(FAILED(hr))
 360             return hr;
 361
 362         cue = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cue));
 363         if (!cue)
 364         {
 365             FACTCue_Destroy(fcue);
 366             ERR("Failed to allocate XACT3CueImpl!\n");
 367             return E_OUTOFMEMORY;
 368         }
 369
 370         cue->IXACT3Cue_iface.lpVtbl = &XACT3Cue_Vtbl;
 371         cue->fact_cue = fcue;
 372         *ppCue = &cue->IXACT3Cue_iface;
 373     }
 374
 375     return hr;
 376 }
 377
 378 static HRESULT WINAPI IXACT3SoundBankImpl_Stop(IXACT3SoundBank *iface,
 379         XACTINDEX nCueIndex, DWORD dwFlags)
 380 {
 381     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 382
 383     TRACE("(%p)->(%lu)\n", This, dwFlags);
 384
 385     return FACTSoundBank_Stop(This->fact_soundbank, nCueIndex, dwFlags);
 386 }
 387
 388 static HRESULT WINAPI IXACT3SoundBankImpl_Destroy(IXACT3SoundBank *iface)
 389 {
 390     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 391     HRESULT hr;
 392
 393     TRACE("(%p)\n", This);
 394
 395     hr = FACTSoundBank_Destroy(This->fact_soundbank);
 396     HeapFree(GetProcessHeap(), 0, This);
 397     return hr;
 398 }
 399
 400 static HRESULT WINAPI IXACT3SoundBankImpl_GetState(IXACT3SoundBank *iface,
 401         DWORD *pdwState)
 402 {
 403     XACT3SoundBankImpl *This = impl_from_IXACT3SoundBank(iface);
 404
 405     TRACE("(%p)->(%p)\n", This, pdwState);
 406
 407     return FACTSoundBank_GetState(This->fact_soundbank, (uint32_t *)pdwState);
 408 }
 409
 410 static const IXACT3SoundBankVtbl XACT3SoundBank_Vtbl =
 411 {
 412     IXACT3SoundBankImpl_GetCueIndex,
 413 #if XACT3_VER >= 0x0205
 414     IXACT3SoundBankImpl_GetNumCues,
 415     IXACT3SoundBankImpl_GetCueProperties,
 416 #endif
 417     IXACT3SoundBankImpl_Prepare,
 418     IXACT3SoundBankImpl_Play,
 419     IXACT3SoundBankImpl_Stop,
 420     IXACT3SoundBankImpl_Destroy,
 421     IXACT3SoundBankImpl_GetState
 422 };
 423
 424 #if XACT3_VER >= 0x0205
 425
 426 typedef struct _XACT3WaveImpl {
 427     IXACT3Wave IXACT3Wave_iface;
 428
 429     FACTWave *fact_wave;
 430 } XACT3WaveImpl;
 431
 432 static inline XACT3WaveImpl *impl_from_IXACT3Wave(IXACT3Wave *iface)
 433 {
 434     return CONTAINING_RECORD(iface, XACT3WaveImpl, IXACT3Wave_iface);
 435 }
 436
 437 static HRESULT WINAPI IXACT3WaveImpl_Destroy(IXACT3Wave *iface)
 438 {
 439     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 440     HRESULT hr;
 441
 442     TRACE("(%p)\n", This);
 443
 444     hr = FACTWave_Destroy(This->fact_wave);
 445     HeapFree(GetProcessHeap(), 0, This);
 446     return hr;
 447 }
 448
 449 static HRESULT WINAPI IXACT3WaveImpl_Play(IXACT3Wave *iface)
 450 {
 451     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 452
 453     TRACE("(%p)\n", This);
 454
 455     return FACTWave_Play(This->fact_wave);
 456 }
 457
 458 static HRESULT WINAPI IXACT3WaveImpl_Stop(IXACT3Wave *iface, DWORD dwFlags)
 459 {
 460     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 461
 462     TRACE("(%p)->(0x%lx)\n", This, dwFlags);
 463
 464     return FACTWave_Stop(This->fact_wave, dwFlags);
 465 }
 466
 467 static HRESULT WINAPI IXACT3WaveImpl_Pause(IXACT3Wave *iface, BOOL fPause)
 468 {
 469     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 470
 471     TRACE("(%p)->(%u)\n", This, fPause);
 472
 473     return FACTWave_Pause(This->fact_wave, fPause);
 474 }
 475
 476 static HRESULT WINAPI IXACT3WaveImpl_GetState(IXACT3Wave *iface, DWORD *pdwState)
 477 {
 478     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 479
 480     TRACE("(%p)->(%p)\n", This, pdwState);
 481
 482     return FACTWave_GetState(This->fact_wave, (uint32_t *)pdwState);
 483 }
 484
 485 static HRESULT WINAPI IXACT3WaveImpl_SetPitch(IXACT3Wave *iface, XACTPITCH pitch)
 486 {
 487     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 488
 489     TRACE("(%p)->(%d)\n", This, pitch);
 490
 491     return FACTWave_SetPitch(This->fact_wave, pitch);
 492 }
 493
 494 static HRESULT WINAPI IXACT3WaveImpl_SetVolume(IXACT3Wave *iface, XACTVOLUME volume)
 495 {
 496     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 497
 498     TRACE("(%p)->(%f)\n", This, volume);
 499
 500     return FACTWave_SetVolume(This->fact_wave, volume);
 501 }
 502
 503 static HRESULT WINAPI IXACT3WaveImpl_SetMatrixCoefficients(IXACT3Wave *iface,
 504         UINT32 uSrcChannelCount, UINT32 uDstChannelCount,
 505         float *pMatrixCoefficients)
 506 {
 507     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 508
 509     TRACE("(%p)->(%u, %u, %p)\n", This, uSrcChannelCount, uDstChannelCount,
 510             pMatrixCoefficients);
 511
 512     return FACTWave_SetMatrixCoefficients(This->fact_wave, uSrcChannelCount,
 513             uDstChannelCount, pMatrixCoefficients);
 514 }
 515
 516 static HRESULT WINAPI IXACT3WaveImpl_GetProperties(IXACT3Wave *iface,
 517     XACT_WAVE_INSTANCE_PROPERTIES *pProperties)
 518 {
 519     XACT3WaveImpl *This = impl_from_IXACT3Wave(iface);
 520
 521     TRACE("(%p)->(%p)\n", This, pProperties);
 522
 523     return FACTWave_GetProperties(This->fact_wave,
 524             (FACTWaveInstanceProperties*) pProperties);
 525 }
 526
 527 static const IXACT3WaveVtbl XACT3Wave_Vtbl =
 528 {
 529     IXACT3WaveImpl_Destroy,
 530     IXACT3WaveImpl_Play,
 531     IXACT3WaveImpl_Stop,
 532     IXACT3WaveImpl_Pause,
 533     IXACT3WaveImpl_GetState,
 534     IXACT3WaveImpl_SetPitch,
 535     IXACT3WaveImpl_SetVolume,
 536     IXACT3WaveImpl_SetMatrixCoefficients,
 537     IXACT3WaveImpl_GetProperties
 538 };
 539
 540 #endif
 541
 542 typedef struct _XACT3WaveBankImpl {
 543     IXACT3WaveBank IXACT3WaveBank_iface;
 544
 545     FACTWaveBank *fact_wavebank;
 546 } XACT3WaveBankImpl;
 547
 548 static inline XACT3WaveBankImpl *impl_from_IXACT3WaveBank(IXACT3WaveBank *iface)
 549 {
 550     return CONTAINING_RECORD(iface, XACT3WaveBankImpl, IXACT3WaveBank_iface);
 551 }
 552
 553 static HRESULT WINAPI IXACT3WaveBankImpl_Destroy(IXACT3WaveBank *iface)
 554 {
 555     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 556     HRESULT hr;
 557
 558     TRACE("(%p)\n", This);
 559
 560     hr = FACTWaveBank_Destroy(This->fact_wavebank);
 561     HeapFree(GetProcessHeap(), 0, This);
 562     return hr;
 563 }
 564
 565 #if XACT3_VER >= 0x0205
 566
 567 static HRESULT WINAPI IXACT3WaveBankImpl_GetNumWaves(IXACT3WaveBank *iface,
 568         XACTINDEX *pnNumWaves)
 569 {
 570     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 571
 572     TRACE("(%p)->(%p)\n", This, pnNumWaves);
 573
 574     return FACTWaveBank_GetNumWaves(This->fact_wavebank, pnNumWaves);
 575 }
 576
 577 static XACTINDEX WINAPI IXACT3WaveBankImpl_GetWaveIndex(IXACT3WaveBank *iface,
 578         PCSTR szFriendlyName)
 579 {
 580     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 581
 582     TRACE("(%p)->(%s)\n", This, szFriendlyName);
 583
 584     return FACTWaveBank_GetWaveIndex(This->fact_wavebank, szFriendlyName);
 585 }
 586
 587 static HRESULT WINAPI IXACT3WaveBankImpl_GetWaveProperties(IXACT3WaveBank *iface,
 588         XACTINDEX nWaveIndex, XACT_WAVE_PROPERTIES *pWaveProperties)
 589 {
 590     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 591
 592     TRACE("(%p)->(%u, %p)\n", This, nWaveIndex, pWaveProperties);
 593
 594     return FACTWaveBank_GetWaveProperties(This->fact_wavebank, nWaveIndex,
 595             (FACTWaveProperties*) pWaveProperties);
 596 }
 597
 598 static HRESULT WINAPI IXACT3WaveBankImpl_Prepare(IXACT3WaveBank *iface,
 599         XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset,
 600         XACTLOOPCOUNT nLoopCount, IXACT3Wave** ppWave)
 601 {
 602     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 603     XACT3WaveImpl *wave;
 604     FACTWave *fwave;
 605     UINT ret;
 606
 607     TRACE("(%p)->(0x%x, %lu, 0x%lx, %u, %p)\n", This, nWaveIndex, dwFlags,
 608             dwPlayOffset, nLoopCount, ppWave);
 609
 610     ret = FACTWaveBank_Prepare(This->fact_wavebank, nWaveIndex, dwFlags,
 611             dwPlayOffset, nLoopCount, &fwave);
 612     if(ret != 0)
 613     {
 614         ERR("Failed to CreateWave: %d\n", ret);
 615         return E_FAIL;
 616     }
 617
 618     wave = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wave));
 619     if (!wave)
 620     {
 621         FACTWave_Destroy(fwave);
 622         ERR("Failed to allocate XACT3WaveImpl!\n");
 623         return E_OUTOFMEMORY;
 624     }
 625
 626     wave->IXACT3Wave_iface.lpVtbl = &XACT3Wave_Vtbl;
 627     wave->fact_wave = fwave;
 628     *ppWave = &wave->IXACT3Wave_iface;
 629
 630     TRACE("Created Wave: %p\n", wave);
 631
 632     return S_OK;
 633 }
 634
 635 static HRESULT WINAPI IXACT3WaveBankImpl_Play(IXACT3WaveBank *iface,
 636         XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset,
 637         XACTLOOPCOUNT nLoopCount, IXACT3Wave** ppWave)
 638 {
 639     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 640     XACT3WaveImpl *wave;
 641     FACTWave *fwave;
 642     HRESULT hr;
 643
 644     TRACE("(%p)->(0x%x, %lu, 0x%lx, %u, %p)\n", This, nWaveIndex, dwFlags, dwPlayOffset,
 645             nLoopCount, ppWave);
 646
 647     /* If the application doesn't want a handle, don't generate one at all.
 648      * Let the engine handle that memory instead.
 649      * -flibit
 650      */
 651     if (ppWave == NULL){
 652         hr = FACTWaveBank_Play(This->fact_wavebank, nWaveIndex, dwFlags,
 653                 dwPlayOffset, nLoopCount, NULL);
 654     }else{
 655         hr = FACTWaveBank_Play(This->fact_wavebank, nWaveIndex, dwFlags,
 656                 dwPlayOffset, nLoopCount, &fwave);
 657         if(FAILED(hr))
 658             return hr;
 659
 660         wave = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wave));
 661         if (!wave)
 662         {
 663             FACTWave_Destroy(fwave);
 664             ERR("Failed to allocate XACT3WaveImpl!\n");
 665             return E_OUTOFMEMORY;
 666         }
 667
 668         wave->IXACT3Wave_iface.lpVtbl = &XACT3Wave_Vtbl;
 669         wave->fact_wave = fwave;
 670         *ppWave = &wave->IXACT3Wave_iface;
 671     }
 672
 673     return hr;
 674 }
 675
 676 static HRESULT WINAPI IXACT3WaveBankImpl_Stop(IXACT3WaveBank *iface,
 677         XACTINDEX nWaveIndex, DWORD dwFlags)
 678 {
 679     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 680
 681     TRACE("(%p)->(%u, %lu)\n", This, nWaveIndex, dwFlags);
 682
 683     return FACTWaveBank_Stop(This->fact_wavebank, nWaveIndex, dwFlags);
 684 }
 685
 686 #endif
 687
 688 static HRESULT WINAPI IXACT3WaveBankImpl_GetState(IXACT3WaveBank *iface,
 689         DWORD *pdwState)
 690 {
 691     XACT3WaveBankImpl *This = impl_from_IXACT3WaveBank(iface);
 692
 693     TRACE("(%p)->(%p)\n", This, pdwState);
 694
 695     return FACTWaveBank_GetState(This->fact_wavebank, (uint32_t *)pdwState);
 696 }
 697
 698 static const IXACT3WaveBankVtbl XACT3WaveBank_Vtbl =
 699 {
 700     IXACT3WaveBankImpl_Destroy,
 701 #if XACT3_VER >= 0x0205
 702     IXACT3WaveBankImpl_GetNumWaves,
 703     IXACT3WaveBankImpl_GetWaveIndex,
 704     IXACT3WaveBankImpl_GetWaveProperties,
 705     IXACT3WaveBankImpl_Prepare,
 706     IXACT3WaveBankImpl_Play,
 707     IXACT3WaveBankImpl_Stop,
 708 #endif
 709     IXACT3WaveBankImpl_GetState
 710 };
 711
 712 typedef struct _XACT3EngineImpl {
 713     IXACT3Engine IXACT3Engine_iface;
 714
 715     FACTAudioEngine *fact_engine;
 716
 717     XACT_READFILE_CALLBACK pReadFile;
 718     XACT_GETOVERLAPPEDRESULT_CALLBACK pGetOverlappedResult;
 719     XACT_NOTIFICATION_CALLBACK notification_callback;
 720 } XACT3EngineImpl;
 721
 722 typedef struct wrap_readfile_struct {
 723     XACT3EngineImpl *engine;
 724     HANDLE file;
 725 } wrap_readfile_struct;
 726
 727 static int32_t FACTCALL wrap_readfile(
 728     void* hFile,
 729     void* lpBuffer,
 730     uint32_t nNumberOfBytesRead,
 731     uint32_t *lpNumberOfBytesRead,
 732     FACTOverlapped *lpOverlapped)
 733 {
 734     wrap_readfile_struct *wrap = (wrap_readfile_struct*) hFile;
 735     return wrap->engine->pReadFile(wrap->file, lpBuffer, nNumberOfBytesRead,
 736             (DWORD *)lpNumberOfBytesRead, (LPOVERLAPPED)lpOverlapped);
 737 }
 738
 739 static int32_t FACTCALL wrap_getoverlappedresult(
 740     void* hFile,
 741     FACTOverlapped *lpOverlapped,
 742     uint32_t *lpNumberOfBytesTransferred,
 743     int32_t bWait)
 744 {
 745     wrap_readfile_struct *wrap = (wrap_readfile_struct*) hFile;
 746     return wrap->engine->pGetOverlappedResult(wrap->file, (LPOVERLAPPED)lpOverlapped,
 747             (DWORD *)lpNumberOfBytesTransferred, bWait);
 748 }
 749
 750 static inline XACT3EngineImpl *impl_from_IXACT3Engine(IXACT3Engine *iface)
 751 {
 752     return CONTAINING_RECORD(iface, XACT3EngineImpl, IXACT3Engine_iface);
 753 }
 754
 755 static HRESULT WINAPI IXACT3EngineImpl_QueryInterface(IXACT3Engine *iface,
 756         REFIID riid, void **ppvObject)
 757 {
 758     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 759
 760     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 761
 762     if(IsEqualGUID(riid, &IID_IUnknown) ||
 763             IsEqualGUID(riid, &IID_IXACT3Engine)){
 764         *ppvObject = &This->IXACT3Engine_iface;
 765     }
 766     else
 767         *ppvObject = NULL;
 768
 769     if (*ppvObject){
 770         IUnknown_AddRef((IUnknown*)*ppvObject);
 771         return S_OK;
 772     }
 773
 774     FIXME("(%p)->(%s,%p), not found\n", This, debugstr_guid(riid), ppvObject);
 775
 776     return E_NOINTERFACE;
 777 }
 778
 779 static ULONG WINAPI IXACT3EngineImpl_AddRef(IXACT3Engine *iface)
 780 {
 781     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 782     ULONG ref = FACTAudioEngine_AddRef(This->fact_engine);
 783     TRACE("(%p)->(): Refcount now %lu\n", This, ref);
 784     return ref;
 785 }
 786
 787 static ULONG WINAPI IXACT3EngineImpl_Release(IXACT3Engine *iface)
 788 {
 789     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 790     ULONG ref = FACTAudioEngine_Release(This->fact_engine);
 791
 792     TRACE("(%p)->(): Refcount now %lu\n", This, ref);
 793
 794     if (!ref)
 795         HeapFree(GetProcessHeap(), 0, This);
 796     return ref;
 797 }
 798
 799 static HRESULT WINAPI IXACT3EngineImpl_GetRendererCount(IXACT3Engine *iface,
 800         XACTINDEX *pnRendererCount)
 801 {
 802     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 803
 804     TRACE("(%p)->(%p)\n", This, pnRendererCount);
 805
 806     return FACTAudioEngine_GetRendererCount(This->fact_engine, pnRendererCount);
 807 }
 808
 809 static HRESULT WINAPI IXACT3EngineImpl_GetRendererDetails(IXACT3Engine *iface,
 810         XACTINDEX nRendererIndex, XACT_RENDERER_DETAILS *pRendererDetails)
 811 {
 812     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 813
 814     TRACE("(%p)->(%d, %p)\n", This, nRendererIndex, pRendererDetails);
 815
 816     return FACTAudioEngine_GetRendererDetails(This->fact_engine,
 817             nRendererIndex, (FACTRendererDetails*) pRendererDetails);
 818 }
 819
 820 #if XACT3_VER >= 0x0205
 821
 822 static HRESULT WINAPI IXACT3EngineImpl_GetFinalMixFormat(IXACT3Engine *iface,
 823         WAVEFORMATEXTENSIBLE *pFinalMixFormat)
 824 {
 825     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 826
 827     TRACE("(%p)->(%p)\n", This, pFinalMixFormat);
 828
 829     return FACTAudioEngine_GetFinalMixFormat(This->fact_engine,
 830             (FAudioWaveFormatExtensible*) pFinalMixFormat);
 831 }
 832
 833 #endif
 834
 835 static void FACTCALL fact_notification_cb(const FACTNotification *notification)
 836 {
 837     XACT3EngineImpl *engine = (XACT3EngineImpl *)notification->pvContext;
 838
 839     /* Older versions of FAudio don't pass through the context */
 840     if (!engine)
 841     {
 842         WARN("Notification context is NULL\n");
 843         return;
 844     }
 845
 846     FIXME("Unsupported callback type %d\n", notification->type);
 847 }
 848
 849 static HRESULT WINAPI IXACT3EngineImpl_Initialize(IXACT3Engine *iface,
 850         const XACT_RUNTIME_PARAMETERS *pParams)
 851 {
 852     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 853     FACTRuntimeParameters params;
 854     UINT ret;
 855
 856     TRACE("(%p)->(%p)\n", This, pParams);
 857
 858     memset(&params, 0, sizeof(FACTRuntimeParameters));
 859     /* Explicitly copy to the FAudio structure as the packing is wrong under 64 bits */
 860     params.lookAheadTime = pParams->lookAheadTime;
 861     params.pGlobalSettingsBuffer = pParams->pGlobalSettingsBuffer;
 862     params.globalSettingsBufferSize = pParams->globalSettingsBufferSize;
 863     params.globalSettingsFlags = pParams->globalSettingsFlags;
 864     params.globalSettingsAllocAttributes = pParams->globalSettingsAllocAttributes;
 865     params.pRendererID = (int16_t*)pParams->pRendererID;
 866     params.pXAudio2 = NULL;
 867     params.pMasteringVoice = NULL;
 868
 869 #if XACT3_VER >= 0x0300
 870     /* FIXME: pXAudio2 and pMasteringVoice are pointers to
 871      * IXAudio2/IXAudio2MasteringVoice objects. FACT wants pointers to
 872      * FAudio/FAudioMasteringVoice objects. In Wine's XAudio2 implementation, we
 873      * actually have them available, but only if you access their internal data.
 874      * For now we can just force these pointers to NULL, as XACT simply
 875      * generates its own engine and endpoint in that situation. These parameters
 876      * are mostly an optimization for games with multiple XACT3Engines that want
 877      * a single engine running everything.
 878      * -flibit
 879      */
 880     if (pParams->pXAudio2 != NULL){
 881         FIXME("pXAudio2 parameter not supported!\n");
 882
 883         if (pParams->pMasteringVoice != NULL){
 884             FIXME("pMasteringVoice parameter not supported!\n");
 885         }
 886     }
 887 #endif
 888
 889     /* Force Windows I/O, do NOT use the FACT default! */
 890     This->pReadFile = (XACT_READFILE_CALLBACK)
 891             pParams->fileIOCallbacks.readFileCallback;
 892     This->pGetOverlappedResult = (XACT_GETOVERLAPPEDRESULT_CALLBACK)
 893             pParams->fileIOCallbacks.getOverlappedResultCallback;
 894     if (This->pReadFile == NULL)
 895         This->pReadFile = (XACT_READFILE_CALLBACK) ReadFile;
 896     if (This->pGetOverlappedResult == NULL)
 897         This->pGetOverlappedResult = (XACT_GETOVERLAPPEDRESULT_CALLBACK)
 898                 GetOverlappedResult;
 899     params.fileIOCallbacks.readFileCallback = wrap_readfile;
 900     params.fileIOCallbacks.getOverlappedResultCallback = wrap_getoverlappedresult;
 901     params.fnNotificationCallback = fact_notification_cb;
 902
 903     This->notification_callback = (XACT_NOTIFICATION_CALLBACK)pParams->fnNotificationCallback;
 904
 905     ret = FACTAudioEngine_Initialize(This->fact_engine, &params);
 906     if (ret != 0)
 907         WARN("FACTAudioEngine_Initialize returned %d\n", ret);
 908
 909     return !ret ? S_OK : E_FAIL;
 910 }
 911
 912 static HRESULT WINAPI IXACT3EngineImpl_ShutDown(IXACT3Engine *iface)
 913 {
 914     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 915
 916     TRACE("(%p)\n", This);
 917
 918     return FACTAudioEngine_ShutDown(This->fact_engine);
 919 }
 920
 921 static HRESULT WINAPI IXACT3EngineImpl_DoWork(IXACT3Engine *iface)
 922 {
 923     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 924
 925     TRACE("(%p)\n", This);
 926
 927     return FACTAudioEngine_DoWork(This->fact_engine);
 928 }
 929
 930 static HRESULT WINAPI IXACT3EngineImpl_CreateSoundBank(IXACT3Engine *iface,
 931         const void* pvBuffer, DWORD dwSize, DWORD dwFlags,
 932         DWORD dwAllocAttributes, IXACT3SoundBank **ppSoundBank)
 933 {
 934     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 935     XACT3SoundBankImpl *sb;
 936     FACTSoundBank *fsb;
 937     UINT ret;
 938
 939     TRACE("(%p)->(%p, %lu, 0x%lx, 0x%lx, %p): stub!\n", This, pvBuffer, dwSize, dwFlags,
 940             dwAllocAttributes, ppSoundBank);
 941
 942     ret = FACTAudioEngine_CreateSoundBank(This->fact_engine, pvBuffer, dwSize,
 943             dwFlags, dwAllocAttributes, &fsb);
 944     if(ret != 0)
 945     {
 946         ERR("Failed to CreateSoundBank: %d\n", ret);
 947         return E_FAIL;
 948     }
 949
 950     sb = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*sb));
 951     if (!sb)
 952     {
 953         FACTSoundBank_Destroy(fsb);
 954         ERR("Failed to allocate XACT3SoundBankImpl!\n");
 955         return E_OUTOFMEMORY;
 956     }
 957
 958     sb->IXACT3SoundBank_iface.lpVtbl = &XACT3SoundBank_Vtbl;
 959     sb->fact_soundbank = fsb;
 960     *ppSoundBank = &sb->IXACT3SoundBank_iface;
 961
 962     TRACE("Created SoundBank: %p\n", sb);
 963
 964     return S_OK;
 965 }
 966
 967 static HRESULT WINAPI IXACT3EngineImpl_CreateInMemoryWaveBank(IXACT3Engine *iface,
 968         const void* pvBuffer, DWORD dwSize, DWORD dwFlags,
 969         DWORD dwAllocAttributes, IXACT3WaveBank **ppWaveBank)
 970 {
 971     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
 972     XACT3WaveBankImpl *wb;
 973     FACTWaveBank *fwb;
 974     UINT ret;
 975
 976     TRACE("(%p)->(%p, %lu, 0x%lx, 0x%lx, %p)\n", This, pvBuffer, dwSize, dwFlags,
 977             dwAllocAttributes, ppWaveBank);
 978
 979     ret = FACTAudioEngine_CreateInMemoryWaveBank(This->fact_engine, pvBuffer,
 980             dwSize, dwFlags, dwAllocAttributes, &fwb);
 981     if(ret != 0)
 982     {
 983         ERR("Failed to CreateWaveBank: %d\n", ret);
 984         return E_FAIL;
 985     }
 986
 987     wb = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wb));
 988     if (!wb)
 989     {
 990         FACTWaveBank_Destroy(fwb);
 991         ERR("Failed to allocate XACT3WaveBankImpl!\n");
 992         return E_OUTOFMEMORY;
 993     }
 994
 995     wb->IXACT3WaveBank_iface.lpVtbl = &XACT3WaveBank_Vtbl;
 996     wb->fact_wavebank = fwb;
 997     *ppWaveBank = &wb->IXACT3WaveBank_iface;
 998
 999     TRACE("Created in-memory WaveBank: %p\n", wb);
1000
1001     return S_OK;
1002 }
1003
1004 static HRESULT WINAPI IXACT3EngineImpl_CreateStreamingWaveBank(IXACT3Engine *iface,
1005         const XACT_WAVEBANK_STREAMING_PARAMETERS *pParms,
1006         IXACT3WaveBank **ppWaveBank)
1007 {
1008     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1009     FACTStreamingParameters fakeParms;
1010     wrap_readfile_struct *fake;
1011     XACT3WaveBankImpl *wb;
1012     FACTWaveBank *fwb;
1013     UINT ret;
1014
1015     TRACE("(%p)->(%p, %p)\n", This, pParms, ppWaveBank);
1016
1017     /* We have to wrap the file to fix up the callbacks! */
1018     fake = (wrap_readfile_struct*) CoTaskMemAlloc(
1019             sizeof(wrap_readfile_struct));
1020     fake->engine = This;
1021     fake->file = pParms->file;
1022     fakeParms.file = fake;
1023     fakeParms.flags = pParms->flags;
1024     fakeParms.offset = pParms->offset;
1025     fakeParms.packetSize = pParms->packetSize;
1026
1027     ret = FACTAudioEngine_CreateStreamingWaveBank(This->fact_engine, &fakeParms,
1028             &fwb);
1029     if(ret != 0)
1030     {
1031         ERR("Failed to CreateWaveBank: %d\n", ret);
1032         return E_FAIL;
1033     }
1034
1035     wb = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wb));
1036     if (!wb)
1037     {
1038         FACTWaveBank_Destroy(fwb);
1039         ERR("Failed to allocate XACT3WaveBankImpl!\n");
1040         return E_OUTOFMEMORY;
1041     }
1042
1043     wb->IXACT3WaveBank_iface.lpVtbl = &XACT3WaveBank_Vtbl;
1044     wb->fact_wavebank = fwb;
1045     *ppWaveBank = &wb->IXACT3WaveBank_iface;
1046
1047     TRACE("Created streaming WaveBank: %p\n", wb);
1048
1049     return S_OK;
1050 }
1051
1052 #if XACT3_VER >= 0x0205
1053
1054 static HRESULT WINAPI IXACT3EngineImpl_PrepareInMemoryWave(IXACT3Engine *iface,
1055         DWORD dwFlags, WAVEBANKENTRY entry, DWORD *pdwSeekTable,
1056         BYTE *pbWaveData, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount,
1057         IXACT3Wave **ppWave)
1058 {
1059     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1060     FIXME("(%p): stub!\n", This);
1061     return E_NOTIMPL;
1062 }
1063
1064 static HRESULT WINAPI IXACT3EngineImpl_PrepareStreamingWave(IXACT3Engine *iface,
1065         DWORD dwFlags, WAVEBANKENTRY entry,
1066         XACT_STREAMING_PARAMETERS streamingParams, DWORD dwAlignment,
1067         DWORD *pdwSeekTable, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount,
1068         IXACT3Wave **ppWave)
1069 {
1070     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1071     FIXME("(%p): stub!\n", This);
1072     return E_NOTIMPL;
1073 }
1074
1075 static HRESULT WINAPI IXACT3EngineImpl_PrepareWave(IXACT3Engine *iface,
1076         DWORD dwFlags, PCSTR szWavePath, WORD wStreamingPacketSize,
1077         DWORD dwAlignment, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount,
1078         IXACT3Wave **ppWave)
1079 {
1080     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1081     XACT3WaveImpl *wave;
1082     FACTWave *fwave = NULL;
1083     UINT ret;
1084
1085     TRACE("(%p)->(0x%08lx, %s, %d, %ld, %ld, %d, %p)\n", This, dwFlags, debugstr_a(szWavePath),
1086           wStreamingPacketSize, dwAlignment, dwPlayOffset, nLoopCount, ppWave);
1087
1088     ret = FACTAudioEngine_PrepareWave(This->fact_engine, dwFlags, szWavePath, wStreamingPacketSize,
1089             dwAlignment, dwPlayOffset, nLoopCount, &fwave);
1090     if(ret != 0 || !fwave)
1091     {
1092         ERR("Failed to CreateWave: %d (%p)\n", ret, fwave);
1093         return E_FAIL;
1094     }
1095
1096     wave = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wave));
1097     if (!wave)
1098     {
1099         FACTWave_Destroy(fwave);
1100         return E_OUTOFMEMORY;
1101     }
1102
1103     wave->IXACT3Wave_iface.lpVtbl = &XACT3Wave_Vtbl;
1104     wave->fact_wave = fwave;
1105     *ppWave = &wave->IXACT3Wave_iface;
1106
1107     TRACE("Created Wave: %p\n", wave);
1108
1109     return S_OK;
1110 }
1111
1112 #endif
1113
1114 enum {
1115     NOTIFY_SoundBank = 0x01,
1116     NOTIFY_WaveBank  = 0x02,
1117     NOTIFY_Cue       = 0x04,
1118     NOTIFY_Wave      = 0x08,
1119     NOTIFY_cueIndex  = 0x10,
1120     NOTIFY_waveIndex = 0x20
1121 };
1122
1123 /* these constants don't have the same values across xactengine versions */
1124 static uint8_t fact_notification_type_from_xact(XACTNOTIFICATIONTYPE type)
1125 {
1126     /* we can't use a switch statement, because the constants are static const
1127      * variables, and some compilers can't deal with that */
1128 #define X(a) if (type == XACTNOTIFICATIONTYPE_##a) return FACTNOTIFICATIONTYPE_##a
1129     X(CUEPREPARED);
1130     X(CUEPLAY);
1131     X(CUESTOP);
1132     X(CUEDESTROYED);
1133     X(MARKER);
1134     X(SOUNDBANKDESTROYED);
1135     X(WAVEBANKDESTROYED);
1136     X(LOCALVARIABLECHANGED);
1137     X(GLOBALVARIABLECHANGED);
1138     X(GUICONNECTED);
1139     X(GUIDISCONNECTED);
1140     X(WAVEPLAY);
1141     X(WAVESTOP);
1142     X(WAVEBANKPREPARED);
1143     X(WAVEBANKSTREAMING_INVALIDCONTENT);
1144 #if XACT3_VER >= 0x0205
1145     X(WAVEPREPARED);
1146     X(WAVELOOPED);
1147     X(WAVEDESTROYED);
1148 #endif
1149 #undef X
1150
1151     FIXME("unknown type %#x\n", type);
1152     return 0;
1153 }
1154
1155 static inline void unwrap_notificationdesc(FACTNotificationDescription *fd,
1156         const XACT_NOTIFICATION_DESCRIPTION *xd)
1157 {
1158     DWORD flags = 0;
1159
1160     TRACE("Type %d\n", xd->type);
1161
1162     memset(fd, 0, sizeof(*fd));
1163
1164     fd->type = fact_notification_type_from_xact(xd->type);
1165
1166     /* we can't use a switch statement, because the constants are static const
1167      * variables, and some compilers can't deal with that */
1168
1169     /* Supports SoundBank, Cue index, Cue instance */
1170     if (fd->type == FACTNOTIFICATIONTYPE_CUEPREPARED || fd->type == FACTNOTIFICATIONTYPE_CUEPLAY ||
1171         fd->type == FACTNOTIFICATIONTYPE_CUESTOP || fd->type == FACTNOTIFICATIONTYPE_CUEDESTROYED ||
1172         fd->type == FACTNOTIFICATIONTYPE_MARKER || fd->type == FACTNOTIFICATIONTYPE_LOCALVARIABLECHANGED)
1173     {
1174         flags = NOTIFY_SoundBank | NOTIFY_cueIndex | NOTIFY_Cue;
1175     }
1176     /* Supports WaveBank */
1177     else if (fd->type == FACTNOTIFICATIONTYPE_WAVEBANKDESTROYED || fd->type == FACTNOTIFICATIONTYPE_WAVEBANKPREPARED ||
1178              fd->type == FACTNOTIFICATIONTYPE_WAVEBANKSTREAMING_INVALIDCONTENT)
1179     {
1180         flags = NOTIFY_WaveBank;
1181     }
1182     /* Supports NOTIFY_SoundBank */
1183     else if (fd->type == FACTNOTIFICATIONTYPE_SOUNDBANKDESTROYED)
1184     {
1185         flags = NOTIFY_SoundBank;
1186     }
1187     /* Supports SoundBank, SoundBank, Cue index, Cue instance, WaveBank, Wave instance */
1188     else if (fd->type == FACTNOTIFICATIONTYPE_WAVEPLAY || fd->type == FACTNOTIFICATIONTYPE_WAVESTOP ||
1189              fd->type == FACTNOTIFICATIONTYPE_WAVELOOPED)
1190     {
1191         flags = NOTIFY_SoundBank | NOTIFY_cueIndex | NOTIFY_Cue | NOTIFY_WaveBank | NOTIFY_Wave;
1192     }
1193     /* Supports WaveBank, Wave index, Wave instance */
1194     else if (fd->type == FACTNOTIFICATIONTYPE_WAVEPREPARED || fd->type == FACTNOTIFICATIONTYPE_WAVEDESTROYED)
1195     {
1196         flags = NOTIFY_WaveBank | NOTIFY_waveIndex | NOTIFY_Wave;
1197     }
1198
1199     /* We have to unwrap the FACT object first! */
1200     fd->flags = xd->flags;
1201     fd->pvContext = xd->pvContext;
1202     if (flags & NOTIFY_cueIndex)
1203         fd->cueIndex = xd->cueIndex;
1204 #if XACT3_VER >= 0x0205
1205     if (flags & NOTIFY_waveIndex)
1206         fd->waveIndex = xd->waveIndex;
1207 #endif
1208
1209     if (flags & NOTIFY_Cue && xd->pCue != NULL)
1210     {
1211         XACT3CueImpl *cue = impl_from_IXACT3Cue(xd->pCue);
1212         if (cue)
1213             fd->pCue = cue->fact_cue;
1214     }
1215
1216     if (flags & NOTIFY_SoundBank && xd->pSoundBank != NULL)
1217     {
1218         XACT3SoundBankImpl *sound = impl_from_IXACT3SoundBank(xd->pSoundBank);
1219         if (sound)
1220             fd->pSoundBank = sound->fact_soundbank;
1221     }
1222
1223     if (flags & NOTIFY_WaveBank && xd->pWaveBank != NULL)
1224     {
1225         XACT3WaveBankImpl *bank = impl_from_IXACT3WaveBank(xd->pWaveBank);
1226         if (bank)
1227             fd->pWaveBank = bank->fact_wavebank;
1228     }
1229
1230 #if XACT3_VER >= 0x0205
1231     if (flags & NOTIFY_Wave && xd->pWave != NULL)
1232     {
1233         XACT3WaveImpl *wave = impl_from_IXACT3Wave(xd->pWave);
1234         if (wave)
1235             fd->pWave = wave->fact_wave;
1236     }
1237 #endif
1238 }
1239
1240 static HRESULT WINAPI IXACT3EngineImpl_RegisterNotification(IXACT3Engine *iface,
1241         const XACT_NOTIFICATION_DESCRIPTION *pNotificationDesc)
1242 {
1243     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1244     FACTNotificationDescription fdesc;
1245
1246     TRACE("(%p)->(%p)\n", This, pNotificationDesc);
1247
1248     unwrap_notificationdesc(&fdesc, pNotificationDesc);
1249     fdesc.pvContext = This;
1250     return FACTAudioEngine_RegisterNotification(This->fact_engine, &fdesc);
1251 }
1252
1253 static HRESULT WINAPI IXACT3EngineImpl_UnRegisterNotification(IXACT3Engine *iface,
1254         const XACT_NOTIFICATION_DESCRIPTION *pNotificationDesc)
1255 {
1256     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1257     FACTNotificationDescription fdesc;
1258
1259     TRACE("(%p)->(%p)\n", This, pNotificationDesc);
1260
1261     unwrap_notificationdesc(&fdesc, pNotificationDesc);
1262     fdesc.pvContext = This;
1263     return FACTAudioEngine_UnRegisterNotification(This->fact_engine, &fdesc);
1264 }
1265
1266 static XACTCATEGORY WINAPI IXACT3EngineImpl_GetCategory(IXACT3Engine *iface,
1267         PCSTR szFriendlyName)
1268 {
1269     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1270
1271     TRACE("(%p)->(%s)\n", This, szFriendlyName);
1272
1273     return FACTAudioEngine_GetCategory(This->fact_engine, szFriendlyName);
1274 }
1275
1276 static HRESULT WINAPI IXACT3EngineImpl_Stop(IXACT3Engine *iface,
1277         XACTCATEGORY nCategory, DWORD dwFlags)
1278 {
1279     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1280
1281     TRACE("(%p)->(%u, 0x%lx)\n", This, nCategory, dwFlags);
1282
1283     return FACTAudioEngine_Stop(This->fact_engine, nCategory, dwFlags);
1284 }
1285
1286 static HRESULT WINAPI IXACT3EngineImpl_SetVolume(IXACT3Engine *iface,
1287         XACTCATEGORY nCategory, XACTVOLUME nVolume)
1288 {
1289     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1290
1291     TRACE("(%p)->(%u, %f)\n", This, nCategory, nVolume);
1292
1293     return FACTAudioEngine_SetVolume(This->fact_engine, nCategory, nVolume);
1294 }
1295
1296 static HRESULT WINAPI IXACT3EngineImpl_Pause(IXACT3Engine *iface,
1297         XACTCATEGORY nCategory, BOOL fPause)
1298 {
1299     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1300
1301     TRACE("(%p)->(%u, %u)\n", This, nCategory, fPause);
1302
1303     return FACTAudioEngine_Pause(This->fact_engine, nCategory, fPause);
1304 }
1305
1306 static XACTVARIABLEINDEX WINAPI IXACT3EngineImpl_GetGlobalVariableIndex(
1307         IXACT3Engine *iface, PCSTR szFriendlyName)
1308 {
1309     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1310
1311     TRACE("(%p)->(%s)\n", This, szFriendlyName);
1312
1313     return FACTAudioEngine_GetGlobalVariableIndex(This->fact_engine,
1314             szFriendlyName);
1315 }
1316
1317 static HRESULT WINAPI IXACT3EngineImpl_SetGlobalVariable(IXACT3Engine *iface,
1318         XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue)
1319 {
1320     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1321
1322     TRACE("(%p)->(%u, %f)\n", This, nIndex, nValue);
1323
1324     return FACTAudioEngine_SetGlobalVariable(This->fact_engine, nIndex, nValue);
1325 }
1326
1327 static HRESULT WINAPI IXACT3EngineImpl_GetGlobalVariable(IXACT3Engine *iface,
1328         XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE *nValue)
1329 {
1330     XACT3EngineImpl *This = impl_from_IXACT3Engine(iface);
1331
1332     TRACE("(%p)->(%u, %p)\n", This, nIndex, nValue);
1333
1334     return FACTAudioEngine_GetGlobalVariable(This->fact_engine, nIndex, nValue);
1335 }
1336
1337 static const IXACT3EngineVtbl XACT3Engine_Vtbl =
1338 {
1339     IXACT3EngineImpl_QueryInterface,
1340     IXACT3EngineImpl_AddRef,
1341     IXACT3EngineImpl_Release,
1342     IXACT3EngineImpl_GetRendererCount,
1343     IXACT3EngineImpl_GetRendererDetails,
1344 #if XACT3_VER >= 0x0205
1345     IXACT3EngineImpl_GetFinalMixFormat,
1346 #endif
1347     IXACT3EngineImpl_Initialize,
1348     IXACT3EngineImpl_ShutDown,
1349     IXACT3EngineImpl_DoWork,
1350     IXACT3EngineImpl_CreateSoundBank,
1351     IXACT3EngineImpl_CreateInMemoryWaveBank,
1352     IXACT3EngineImpl_CreateStreamingWaveBank,
1353 #if XACT3_VER >= 0x0205
1354     IXACT3EngineImpl_PrepareWave,
1355     IXACT3EngineImpl_PrepareInMemoryWave,
1356     IXACT3EngineImpl_PrepareStreamingWave,
1357 #endif
1358     IXACT3EngineImpl_RegisterNotification,
1359     IXACT3EngineImpl_UnRegisterNotification,
1360     IXACT3EngineImpl_GetCategory,
1361     IXACT3EngineImpl_Stop,
1362     IXACT3EngineImpl_SetVolume,
1363     IXACT3EngineImpl_Pause,
1364     IXACT3EngineImpl_GetGlobalVariableIndex,
1365     IXACT3EngineImpl_SetGlobalVariable,
1366     IXACT3EngineImpl_GetGlobalVariable
1367 };
1368
1369 void* XACT_Internal_Malloc(size_t size)
1370 {
1371     return CoTaskMemAlloc(size);
1372 }
1373
1374 void XACT_Internal_Free(void* ptr)
1375 {
1376     return CoTaskMemFree(ptr);
1377 }
1378
1379 void* XACT_Internal_Realloc(void* ptr, size_t size)
1380 {
1381     return CoTaskMemRealloc(ptr, size);
1382 }
1383
1384 static HRESULT WINAPI XACT3CF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppobj)
1385 {
1386     if(IsEqualGUID(riid, &IID_IUnknown) ||
1387        IsEqualGUID(riid, &IID_IClassFactory))
1388     {
1389         *ppobj = iface;
1390         return S_OK;
1391     }
1392
1393     *ppobj = NULL;
1394     WARN("(%p)->(%s, %p): interface not found\n", iface, debugstr_guid(riid), ppobj);
1395     return E_NOINTERFACE;
1396 }
1397
1398 static ULONG WINAPI XACT3CF_AddRef(IClassFactory *iface)
1399 {
1400     return 2;
1401 }
1402
1403 static ULONG WINAPI XACT3CF_Release(IClassFactory *iface)
1404 {
1405     return 1;
1406 }
1407
1408 static HRESULT WINAPI XACT3CF_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
1409                                                REFIID riid, void **ppobj)
1410 {
1411     HRESULT hr;
1412     XACT3EngineImpl *object;
1413
1414     TRACE("(%p)->(%p,%s,%p)\n", iface, pOuter, debugstr_guid(riid), ppobj);
1415
1416     *ppobj = NULL;
1417
1418     if(pOuter)
1419         return CLASS_E_NOAGGREGATION;
1420
1421     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1422     if(!object)
1423         return E_OUTOFMEMORY;
1424
1425     object->IXACT3Engine_iface.lpVtbl = &XACT3Engine_Vtbl;
1426
1427     FACTCreateEngineWithCustomAllocatorEXT(
1428         0,
1429         &object->fact_engine,
1430         XACT_Internal_Malloc,
1431         XACT_Internal_Free,
1432         XACT_Internal_Realloc
1433     );
1434
1435     hr = IXACT3Engine_QueryInterface(&object->IXACT3Engine_iface, riid, ppobj);
1436     if(FAILED(hr)){
1437         HeapFree(GetProcessHeap(), 0, object);
1438         return hr;
1439     }
1440
1441     return hr;
1442 }
1443
1444 static HRESULT WINAPI XACT3CF_LockServer(IClassFactory *iface, BOOL dolock)
1445 {
1446     TRACE("(%p)->(%d): stub!\n", iface, dolock);
1447     return S_OK;
1448 }
1449
1450 static const IClassFactoryVtbl XACT3CF_Vtbl =
1451 {
1452     XACT3CF_QueryInterface,
1453     XACT3CF_AddRef,
1454     XACT3CF_Release,
1455     XACT3CF_CreateInstance,
1456     XACT3CF_LockServer
1457 };
1458
1459 static IClassFactory XACTFactory = { &XACT3CF_Vtbl };
1460
1461 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, void *pReserved)
1462 {
1463     TRACE("(%p, %ld, %p)\n", hinstDLL, reason, pReserved);
1464
1465     switch (reason)
1466     {
1467     case DLL_PROCESS_ATTACH:
1468         DisableThreadLibraryCalls( hinstDLL );
1469         TRACE("Using FAudio version %d\n", FAudioLinkedVersion() );
1470         break;
1471     }
1472     return TRUE;
1473 }
1474
1475 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
1476 {
1477     if (IsEqualGUID(rclsid, &CLSID_XACTEngine))
1478     {
1479         TRACE("(%s, %s, %p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1480         return IClassFactory_QueryInterface(&XACTFactory, riid, ppv);
1481     }
1482
1483     FIXME("Unknown class %s\n", debugstr_guid(rclsid));
1484     return CLASS_E_CLASSNOTAVAILABLE;
1485 }