alysbrooks-public » games » isometric-park-fna

Location: alysbrooks-public/games/isometric-park-fna/FNA/lib/FAudio/cpp/xact3.cpp - annotation

Show More
Commit Description:
Lots of cleanup.
Commit Description:
Lots of cleanup.
References:
r149:95f3c80f070b default
File last commit:
r0:e33f209de7e5 default
Show/Diff file:
Action:
FNA/lib/FAudio/cpp/xact3.cpp
668 lines | 14.7 KiB | text/x-c | CppLexer
History | Source | Raw | Download
alys
Early working version (including all dependencies, lol).
 r0 #include "xact3.h"
#include <assert.h>
extern "C" int32_t FACTCALL ReadFile(
void* hFile,
void* lpBuffer,
uint32_t nNumberOfBytesToRead,
uint32_t *lpNumberOfBytesRead,
FACTOverlapped *lpOverlapped
);
extern "C" int32_t FACTCALL GetOverlappedResult(
void* hFile,
FACTOverlapped *lpOverlapped,
uint32_t *lpNumberOfBytesTransferred,
int32_t bWait
);
/* IXACT3Cue Implementation */
class XACT3CueImpl : public IXACT3Cue
{
public:
XACT3CueImpl(FACTCue *newCue)
{
cue = newCue;
}
COM_METHOD(HRESULT) Play()
{
return FACTCue_Play(cue);
}
COM_METHOD(HRESULT) Stop(uint32_t dwFlags)
{
return FACTCue_Stop(cue, dwFlags);
};
COM_METHOD(HRESULT) GetState(uint32_t *pdwState)
{
return FACTCue_GetState(cue, pdwState);
}
COM_METHOD(HRESULT) Destroy()
{
return FACTCue_Destroy(cue);
}
COM_METHOD(HRESULT) SetMatrixCoefficients(
uint32_t uSrcChannelCount,
uint32_t uDstChannelCount,
float *pMatrixCoefficients
) {
return FACTCue_SetMatrixCoefficients(
cue,
uSrcChannelCount,
uDstChannelCount,
pMatrixCoefficients
);
}
COM_METHOD(uint16_t) GetVariableIndex(const char *szFriendlyName)
{
return FACTCue_GetVariableIndex(cue, szFriendlyName);
}
COM_METHOD(HRESULT) SetVariable(uint16_t nIndex, float nValue)
{
return FACTCue_SetVariable(cue, nIndex, nValue);
}
COM_METHOD(HRESULT) GetVariable(uint16_t nIndex, float *nValue)
{
return FACTCue_GetVariable(cue, nIndex, nValue);
}
COM_METHOD(HRESULT) Pause(int32_t fPause)
{
return FACTCue_Pause(cue, fPause);
}
COM_METHOD(HRESULT) GetProperties(
XACT_CUE_INSTANCE_PROPERTIES **ppProperties
) {
return FACTCue_GetProperties(cue, ppProperties);
}
#if XACT3_VERSION >= 5
COM_METHOD(HRESULT) SetOutputVoices(
const XAUDIO2_VOICE_SENDS *pSendList /* Optional! */
) {
/* TODO: SetOutputVoices */
return 0;
}
COM_METHOD(HRESULT) SetOutputVoiceMatrix(
const IXAudio2Voice *pDestinationVoice, /* Optional! */
uint32_t SourceChannels,
uint32_t DestinationChannels,
const float *pLevelMatrix /* SourceChannels * DestinationChannels */
) {
/* TODO: SetOutputVoiceMatrix */
return 0;
}
#endif /* #if XACT3_VERSION >= 5 */
FACTCue *cue;
};
/* IXACT3Wave Implementation */
class XACT3WaveImpl : public IXACT3Wave
{
public:
XACT3WaveImpl(FACTWave *newWave)
{
wave = newWave;
}
COM_METHOD(HRESULT) Destroy()
{
return FACTWave_Destroy(wave);
}
COM_METHOD(HRESULT) Play()
{
return FACTWave_Play(wave);
}
COM_METHOD(HRESULT) Stop(uint32_t dwFlags)
{
return FACTWave_Stop(wave, dwFlags);
}
COM_METHOD(HRESULT) Pause(int32_t fPause)
{
return FACTWave_Pause(wave, fPause);
}
COM_METHOD(HRESULT) GetState(uint32_t *pdwState)
{
return FACTWave_GetState(wave, pdwState);
}
COM_METHOD(HRESULT) SetPitch(int16_t pitch)
{
return FACTWave_SetPitch(wave, pitch);
}
COM_METHOD(HRESULT) SetVolume(float volume)
{
return FACTWave_SetVolume(wave, volume);
}
COM_METHOD(HRESULT) SetMatrixCoefficients(
uint32_t uSrcChannelCount,
uint32_t uDstChannelCount,
float *pMatrixCoefficients
) {
return FACTWave_SetMatrixCoefficients(
wave,
uSrcChannelCount,
uDstChannelCount,
pMatrixCoefficients
);
}
COM_METHOD(HRESULT) GetProperties(
XACT_WAVE_INSTANCE_PROPERTIES *pProperties
) {
return FACTWave_GetProperties(wave, pProperties);
}
FACTWave *wave;
};
/* IXACT3SoundBank Implementation */
class XACT3SoundBankImpl : public IXACT3SoundBank
{
public:
XACT3SoundBankImpl(FACTSoundBank *newSoundBank)
{
soundBank = newSoundBank;
}
COM_METHOD(uint16_t) GetCueIndex(const char *szFriendlyName)
{
return FACTSoundBank_GetCueIndex(soundBank, szFriendlyName);
}
COM_METHOD(HRESULT) GetNumCues(uint16_t *pnNumCues)
{
return FACTSoundBank_GetNumCues(soundBank, pnNumCues);
}
COM_METHOD(HRESULT) GetCueProperties(
uint16_t nCueIndex,
XACT_CUE_PROPERTIES *pProperties
) {
return FACTSoundBank_GetCueProperties(
soundBank,
nCueIndex,
pProperties
);
}
COM_METHOD(HRESULT) Prepare(
uint16_t nCueIndex,
uint32_t dwFlags,
int32_t timeOffset,
IXACT3Cue** ppCue
) {
FACTCue *cue;
HRESULT retval = FACTSoundBank_Prepare(
soundBank,
nCueIndex,
dwFlags,
timeOffset,
&cue
);
*ppCue = new XACT3CueImpl(cue);
return retval;
}
COM_METHOD(HRESULT) Play(
uint16_t nCueIndex,
uint32_t dwFlags,
int32_t timeOffset,
IXACT3Cue** ppCue /* Optional! */
) {
if (ppCue == NULL)
{
return FACTSoundBank_Play(
soundBank,
nCueIndex,
dwFlags,
timeOffset,
NULL
);
}
FACTCue *cue;
HRESULT retval = FACTSoundBank_Play(
soundBank,
nCueIndex,
dwFlags,
timeOffset,
&cue
);
*ppCue = new XACT3CueImpl(cue);
return retval;
}
COM_METHOD(HRESULT) Stop(uint16_t nCueIndex, uint32_t dwFlags)
{
return FACTSoundBank_Stop(soundBank, nCueIndex, dwFlags);
}
COM_METHOD(HRESULT) Destroy()
{
return FACTSoundBank_Destroy(soundBank);
}
COM_METHOD(HRESULT) GetState(uint32_t *pdwState)
{
return FACTSoundBank_GetState(soundBank, pdwState);
}
FACTSoundBank *soundBank;
};
/* IXACT3WaveBank Implementation */
class XACT3WaveBankImpl : public IXACT3WaveBank
{
public:
XACT3WaveBankImpl(FACTWaveBank *newWaveBank)
{
waveBank = newWaveBank;
}
COM_METHOD(HRESULT) Destroy()
{
return FACTWaveBank_Destroy(waveBank);
}
COM_METHOD(HRESULT) GetNumWaves(uint16_t *pnNumWaves)
{
return FACTWaveBank_GetNumWaves(waveBank, pnNumWaves);
}
COM_METHOD(uint16_t) GetWaveIndex(const char *szFriendlyName)
{
return FACTWaveBank_GetWaveIndex(waveBank, szFriendlyName);
}
COM_METHOD(HRESULT) GetWaveProperties(
uint16_t nWaveIndex,
XACT_WAVE_PROPERTIES *pWaveProperties
) {
return FACTWaveBank_GetWaveProperties(
waveBank,
nWaveIndex,
pWaveProperties
);
}
COM_METHOD(HRESULT) Prepare(
uint16_t nWaveIndex,
uint32_t dwFlags,
uint32_t dwPlayOffset,
uint8_t nLoopCount,
IXACT3Wave **ppWave
) {
FACTWave *wave;
HRESULT retval = FACTWaveBank_Prepare(
waveBank,
nWaveIndex,
dwFlags,
dwPlayOffset,
nLoopCount,
&wave
);
*ppWave = new XACT3WaveImpl(wave);
return retval;
}
COM_METHOD(HRESULT) Play(
uint16_t nWaveIndex,
uint32_t dwFlags,
uint32_t dwPlayOffset,
uint8_t nLoopCount,
IXACT3Wave **ppWave
) {
if (ppWave == NULL)
{
return FACTWaveBank_Play(
waveBank,
nWaveIndex,
dwFlags,
dwPlayOffset,
nLoopCount,
NULL
);
}
FACTWave *wave;
HRESULT retval = FACTWaveBank_Play(
waveBank,
nWaveIndex,
dwFlags,
dwPlayOffset,
nLoopCount,
&wave
);
*ppWave = new XACT3WaveImpl(wave);
return retval;
}
COM_METHOD(HRESULT) Stop(
uint16_t nWaveIndex,
uint32_t dwFlags
) {
return FACTWaveBank_Stop(waveBank, nWaveIndex, dwFlags);
}
COM_METHOD(HRESULT) GetState(uint32_t *pdwState)
{
return FACTWaveBank_GetState(waveBank, pdwState);
}
FACTWaveBank *waveBank;
};
/* IXACT3Engine Implementation */
void* CDECL XACT3_INTERNAL_Malloc(size_t size)
{
return CoTaskMemAlloc(size);
}
void CDECL XACT3_INTERNAL_Free(void* ptr)
{
CoTaskMemFree(ptr);
}
void* CDECL XACT3_INTERNAL_Realloc(void* ptr, size_t size)
{
return CoTaskMemRealloc(ptr, size);
}
class XACT3EngineImpl : public IXACT3Engine
{
public:
XACT3EngineImpl()
{
FACTCreateEngineWithCustomAllocatorEXT(
0,
&engine,
XACT3_INTERNAL_Malloc,
XACT3_INTERNAL_Free,
XACT3_INTERNAL_Realloc
);
}
COM_METHOD(HRESULT) QueryInterface(REFIID riid, void **ppvInterface)
{
if (guid_equals(riid, IID_IXACT3Engine))
{
*ppvInterface = static_cast<IXACT3Engine *>(this);
}
else if (guid_equals(riid, IID_IUnknown))
{
*ppvInterface = static_cast<IUnknown *>(this);
}
else
{
*ppvInterface = NULL;
return E_NOINTERFACE;
}
reinterpret_cast<IUnknown *>(*ppvInterface)->AddRef();
return S_OK;
}
COM_METHOD(ULONG) AddRef()
{
return FACTAudioEngine_AddRef(engine);
}
COM_METHOD(ULONG) Release()
{
ULONG refcount = FACTAudioEngine_Release(engine);
if (refcount == 0)
{
delete this;
}
return 1;
}
COM_METHOD(HRESULT) GetRendererCount(
uint16_t *pnRendererCount
) {
return FACTAudioEngine_GetRendererCount(
engine,
pnRendererCount
);
}
COM_METHOD(HRESULT) GetRendererDetails(
uint16_t nRendererIndex,
XACT_RENDERER_DETAILS *pRendererDetails
) {
return FACTAudioEngine_GetRendererDetails(
engine,
nRendererIndex,
pRendererDetails
);
}
COM_METHOD(HRESULT) GetFinalMixFormat(
WAVEFORMATEXTENSIBLE *pFinalMixFormat
) {
return FACTAudioEngine_GetFinalMixFormat(
engine,
pFinalMixFormat
);
}
COM_METHOD(HRESULT) Initialize(
const XACT_RUNTIME_PARAMETERS *pParams
) {
XACT_RUNTIME_PARAMETERS params;
/* TODO: Unwrap FAudio/FAudioMasteringVoice */
assert(pParams->pXAudio2 == NULL);
assert(pParams->pMasteringVoice == NULL);
/* Copy so we can modify the parameters a bit... */
params = *pParams;
params.pXAudio2 = NULL;
params.pMasteringVoice = NULL;
/* Force Win32 I/O, do NOT use the default! */
if (pParams->fileIOCallbacks.readFileCallback == NULL)
{
params.fileIOCallbacks.readFileCallback = ReadFile;
}
if (pParams->fileIOCallbacks.getOverlappedResultCallback == NULL)
{
params.fileIOCallbacks.getOverlappedResultCallback = GetOverlappedResult;
}
return FACTAudioEngine_Initialize(engine, &params);
}
COM_METHOD(HRESULT) ShutDown()
{
return FACTAudioEngine_ShutDown(engine);
}
COM_METHOD(HRESULT) DoWork()
{
return FACTAudioEngine_DoWork(engine);
}
COM_METHOD(HRESULT) CreateSoundBank(
const void *pvBuffer,
uint32_t dwSize,
uint32_t dwFlags,
uint32_t dwAllocAttributes,
IXACT3SoundBank **ppSoundBank
) {
FACTSoundBank *soundBank;
HRESULT retval = FACTAudioEngine_CreateSoundBank(
engine,
pvBuffer,
dwSize,
dwFlags,
dwAllocAttributes,
&soundBank
);
*ppSoundBank = new XACT3SoundBankImpl(soundBank);
return retval;
}
COM_METHOD(HRESULT) CreateInMemoryWaveBank(
const void *pvBuffer,
uint32_t dwSize,
uint32_t dwFlags,
uint32_t dwAllocAttributes,
IXACT3WaveBank **ppWaveBank
) {
FACTWaveBank *waveBank;
HRESULT retval = FACTAudioEngine_CreateInMemoryWaveBank(
engine,
pvBuffer,
dwSize,
dwFlags,
dwAllocAttributes,
&waveBank
);
*ppWaveBank = new XACT3WaveBankImpl(waveBank);
return retval;
}
COM_METHOD(HRESULT) CreateStreamingWaveBank(
const XACT_STREAMING_PARAMETERS *pParms,
IXACT3WaveBank **ppWaveBank
) {
FACTWaveBank *waveBank;
HRESULT retval = FACTAudioEngine_CreateStreamingWaveBank(
engine,
pParms,
&waveBank
);
*ppWaveBank = new XACT3WaveBankImpl(waveBank);
return retval;
}
COM_METHOD(HRESULT) PrepareWave(
uint32_t dwFlags,
const char *szWavePath,
uint32_t wStreamingPacketSize,
uint32_t dwAlignment,
uint32_t dwPlayOffset,
uint8_t nLoopCount,
IXACT3Wave **ppWave
) {
/* TODO: See FACT.c */
return 0;
}
COM_METHOD(HRESULT) PrepareInMemoryWave(
uint32_t dwFlags,
WAVEBANKENTRY entry,
uint32_t *pdwSeekTable, /* Optional! */
uint8_t *pbWaveData,
uint32_t dwPlayOffset,
uint8_t nLoopCount,
IXACT3Wave **ppWave
) {
/* TODO: See FACT.c */
return 0;
}
COM_METHOD(HRESULT) PrepareStreamingWave(
uint32_t dwFlags,
WAVEBANKENTRY entry,
XACT_STREAMING_PARAMETERS streamingParams,
uint32_t dwAlignment,
uint32_t *pdwSeekTable, /* Optional! */
uint8_t *pbWaveData,
uint32_t dwPlayOffset,
uint8_t nLoopCount,
IXACT3Wave **ppWave
) {
/* TODO: See FACT.c */
return 0;
}
COM_METHOD(HRESULT) RegisterNotification(
const XACT_NOTIFICATION_DESCRIPTION *pNotificationDescription
) {
/* We have to unwrap the FACT object first! */
FACTNotificationDescription desc;
desc.type = pNotificationDescription->type;
desc.flags = pNotificationDescription->flags;
desc.cueIndex = pNotificationDescription->cueIndex;
desc.waveIndex = pNotificationDescription->waveIndex;
desc.pvContext = pNotificationDescription->pvContext;
if (desc.type == FACTNOTIFICATIONTYPE_CUEDESTROYED)
{
desc.pCue = ((XACT3CueImpl*) pNotificationDescription->pCue)->cue;
}
else if (desc.type == FACTNOTIFICATIONTYPE_SOUNDBANKDESTROYED)
{
if (pNotificationDescription->pSoundBank != NULL)
{
desc.pSoundBank = ((XACT3SoundBankImpl*) pNotificationDescription->pSoundBank)->soundBank;
}
else
{
desc.pSoundBank = NULL;
}
}
else if (desc.type == FACTNOTIFICATIONTYPE_WAVEBANKDESTROYED)
{
desc.pWaveBank = ((XACT3WaveBankImpl*) pNotificationDescription->pWaveBank)->waveBank;
}
else if (desc.type == FACTNOTIFICATIONTYPE_WAVEDESTROYED)
{
desc.pWave = ((XACT3WaveImpl*) pNotificationDescription->pWave)->wave;
}
// If you didn't hit an above if, get ready for an assert!
return FACTAudioEngine_RegisterNotification(engine, &desc);
}
COM_METHOD(HRESULT) UnRegisterNotification(
const XACT_NOTIFICATION_DESCRIPTION *pNotificationDescription
) {
/* We have to unwrap the FACT object first! */
FACTNotificationDescription desc;
desc.type = pNotificationDescription->type;
desc.flags = pNotificationDescription->flags;
desc.cueIndex = pNotificationDescription->cueIndex;
desc.waveIndex = pNotificationDescription->waveIndex;
desc.pvContext = pNotificationDescription->pvContext;
if (desc.type == FACTNOTIFICATIONTYPE_CUEDESTROYED)
{
desc.pCue = ((XACT3CueImpl*) pNotificationDescription->pCue)->cue;
}
else if (desc.type == FACTNOTIFICATIONTYPE_SOUNDBANKDESTROYED)
{
desc.pSoundBank = ((XACT3SoundBankImpl*) pNotificationDescription->pSoundBank)->soundBank;
}
else if (desc.type == FACTNOTIFICATIONTYPE_WAVEBANKDESTROYED)
{
desc.pWaveBank = ((XACT3WaveBankImpl*) pNotificationDescription->pWaveBank)->waveBank;
}
else if (desc.type == FACTNOTIFICATIONTYPE_WAVEDESTROYED)
{
desc.pWave = ((XACT3WaveImpl*) pNotificationDescription->pWave)->wave;
}
// If you didn't hit an above if, get ready for an assert!
return FACTAudioEngine_UnRegisterNotification(engine, &desc);
}
COM_METHOD(uint16_t) GetCategory(const char *szFriendlyName)
{
return FACTAudioEngine_GetCategory(engine, szFriendlyName);
}
COM_METHOD(HRESULT) Stop(uint16_t nCategory, uint32_t dwFlags)
{
return FACTAudioEngine_Stop(engine, nCategory, dwFlags);
}
COM_METHOD(HRESULT) SetVolume(uint16_t nCategory, float volume)
{
return FACTAudioEngine_SetVolume(engine, nCategory, volume);
}
COM_METHOD(HRESULT) Pause(uint16_t nCategory, int32_t fPause)
{
return FACTAudioEngine_Pause(engine, nCategory, fPause);
}
COM_METHOD(uint16_t) GetGlobalVariableIndex(
const char *szFriendlyName
) {
return FACTAudioEngine_GetGlobalVariableIndex(
engine,
szFriendlyName
);
}
COM_METHOD(HRESULT) SetGlobalVariable(
uint16_t nIndex,
float nValue
) {
return FACTAudioEngine_SetGlobalVariable(
engine,
nIndex,
nValue
);
}
COM_METHOD(HRESULT) GetGlobalVariable(
uint16_t nIndex,
float *pnValue
) {
return FACTAudioEngine_GetGlobalVariable(
engine,
nIndex,
pnValue
);
}
private:
FACTAudioEngine *engine;
};
/* Create Function */
void *CreateXACT3EngineInternal()
{
return new XACT3EngineImpl();
}