alysbrooks-public » games » isometric-park-fna

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

Show More
Commit Description:
Various UI improvements.
Commit Description:
Various UI improvements.
References:
r291:6a7d5e8510b1 default
File last commit:
r0:e33f209de7e5 default
Show/Diff file:
Action:
FNA/lib/FAudio/cpp/XAPOBase.cpp
292 lines | 6.4 KiB | text/x-c | CppLexer
History | Source | Raw | Download
alys
Early working version (including all dependencies, lol).
 r0 #include "XAPOBase.h"
#include <assert.h>
///////////////////////////////////////////////////////////////////////////////
//
// CXAPOBase
//
void* CDECL XAPOBase_INTERNAL_Malloc(size_t size)
{
return CoTaskMemAlloc(size);
}
void CDECL XAPOBase_INTERNAL_Free(void* ptr)
{
CoTaskMemFree(ptr);
}
void* CDECL XAPOBase_INTERNAL_Realloc(void* ptr, size_t size)
{
return CoTaskMemRealloc(ptr, size);
}
CXAPOBase::CXAPOBase(FAPOBase *base)
: fapo_base(base),
own_fapo_base(false)
{
}
CXAPOBase::CXAPOBase(const XAPO_REGISTRATION_PROPERTIES* pRegistrationProperties,
BYTE* pParameterBlocks,
UINT32 uParameterBlockByteSize,
BOOL fProducer)
: fapo_base(new FAPOBase()),
own_fapo_base(true)
{
CreateFAPOBaseWithCustomAllocatorEXT(
fapo_base,
pRegistrationProperties,
pParameterBlocks,
uParameterBlockByteSize,
fProducer,
XAPOBase_INTERNAL_Malloc,
XAPOBase_INTERNAL_Free,
XAPOBase_INTERNAL_Realloc
);
}
CXAPOBase::~CXAPOBase()
{
if (own_fapo_base)
{
delete fapo_base;
}
else if (fapo_base->Destructor)
{
fapo_base->Destructor(fapo_base);
}
}
HRESULT CXAPOBase::QueryInterface(REFIID riid, void** ppInterface)
{
if (guid_equals(riid, IID_IXAPO))
{
*ppInterface = static_cast<IXAPO *>(this);
}
else if (guid_equals(riid, IID_IUnknown))
{
*ppInterface = static_cast<IUnknown *>(this);
}
else
{
*ppInterface = NULL;
return E_NOINTERFACE;
}
reinterpret_cast<IUnknown *>(*ppInterface)->AddRef();
return S_OK;
}
ULONG CXAPOBase::AddRef()
{
return FAPOBase_AddRef(fapo_base);
}
ULONG CXAPOBase::Release()
{
ULONG refcount = FAPOBase_Release(fapo_base);
if (refcount == 0)
{
delete this;
}
return refcount;
}
HRESULT CXAPOBase::GetRegistrationProperties(XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties)
{
assert(fapo_base->base.GetRegistrationProperties != NULL);
return fapo_base->base.GetRegistrationProperties(fapo_base, ppRegistrationProperties);
}
HRESULT CXAPOBase::IsInputFormatSupported(
const WAVEFORMATEX* pOutputFormat,
const WAVEFORMATEX* pRequestedInputFormat,
WAVEFORMATEX** ppSupportedInputFormat
) {
assert(fapo_base->base.IsInputFormatSupported != NULL);
return fapo_base->base.IsInputFormatSupported(
fapo_base,
pOutputFormat,
pRequestedInputFormat,
ppSupportedInputFormat);
}
HRESULT CXAPOBase::IsOutputFormatSupported(
const WAVEFORMATEX* pInputFormat,
const WAVEFORMATEX* pRequestedOutputFormat,
WAVEFORMATEX** ppSupportedOutputFormat
) {
assert(fapo_base->base.IsOutputFormatSupported != NULL);
return fapo_base->base.IsOutputFormatSupported(
fapo_base,
pInputFormat,
pRequestedOutputFormat,
ppSupportedOutputFormat);
}
HRESULT CXAPOBase::Initialize(const void*pData, UINT32 DataByteSize)
{
assert(fapo_base->base.Initialize != NULL);
return fapo_base->base.Initialize(fapo_base, pData, DataByteSize);
}
void CXAPOBase::Reset()
{
assert(fapo_base->base.Reset != NULL);
fapo_base->base.Reset(fapo_base);
}
HRESULT CXAPOBase::LockForProcess(
UINT32 InputLockedParameterCount,
const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,
UINT32 OutputLockedParameterCount,
const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters
) {
assert(fapo_base->base.LockForProcess != NULL);
return fapo_base->base.LockForProcess(
fapo_base,
InputLockedParameterCount,
pInputLockedParameters,
OutputLockedParameterCount,
pOutputLockedParameters);
}
void CXAPOBase::UnlockForProcess()
{
assert(fapo_base->base.UnlockForProcess != NULL);
fapo_base->base.UnlockForProcess(fapo_base);
}
UINT32 CXAPOBase::CalcInputFrames(UINT32 OutputFrameCount)
{
assert(fapo_base->base.CalcInputFrames != NULL);
return fapo_base->base.CalcInputFrames(fapo_base, OutputFrameCount);
}
UINT32 CXAPOBase::CalcOutputFrames(UINT32 InputFrameCount)
{
assert(fapo_base->base.CalcOutputFrames != NULL);
return fapo_base->base.CalcOutputFrames(fapo_base, InputFrameCount);
}
// protected functions
HRESULT CXAPOBase::ValidateFormatDefault(WAVEFORMATEX* pFormat, BOOL fOverwrite)
{
return FAPOBase_ValidateFormatDefault(fapo_base, pFormat, fOverwrite);
}
HRESULT CXAPOBase::ValidateFormatPair(
const WAVEFORMATEX* pSupportedFormat,
WAVEFORMATEX* pRequestedFormat,
BOOL fOverwrite
) {
return FAPOBase_ValidateFormatPair(
fapo_base,
pSupportedFormat,
pRequestedFormat,
fOverwrite);
}
void CXAPOBase::ProcessThru(
void* pInputBuffer,
FLOAT32* pOutputBuffer,
UINT32 FrameCount,
WORD InputChannelCount,
WORD OutputChannelCount,
BOOL MixWithOutput)
{
FAPOBase_ProcessThru(
fapo_base,
pInputBuffer,
pOutputBuffer,
FrameCount,
InputChannelCount,
OutputChannelCount,
MixWithOutput);
}
BOOL CXAPOBase::IsLocked()
{
return fapo_base->m_fIsLocked;
}
///////////////////////////////////////////////////////////////////////////////
//
// CXAPOParametersBase
//
CXAPOParametersBase::CXAPOParametersBase(FAPOBase *base)
: CXAPOBase(base)
{
}
CXAPOParametersBase::CXAPOParametersBase(
const XAPO_REGISTRATION_PROPERTIES* pRegistrationProperties,
BYTE* pParameterBlocks,
UINT32 uParameterBlockByteSize,
BOOL fProducer)
: CXAPOBase(pRegistrationProperties, pParameterBlocks,
uParameterBlockByteSize, fProducer)
{
}
CXAPOParametersBase::~CXAPOParametersBase()
{
}
HRESULT CXAPOParametersBase::QueryInterface(REFIID riid, void** ppInterface)
{
if (guid_equals(riid, IID_IXAPOParameters))
{
*ppInterface = static_cast<IXAPOParameters *>(this);
CXAPOBase::AddRef();
return S_OK;
}
else
{
return CXAPOBase::QueryInterface(riid, ppInterface);
}
}
ULONG CXAPOParametersBase::AddRef()
{
return CXAPOBase::AddRef();
}
ULONG CXAPOParametersBase::Release()
{
return CXAPOBase::Release();
}
void CXAPOParametersBase::SetParameters(const void* pParameters, UINT32 ParameterByteSize)
{
assert(fapo_base->base.SetParameters);
fapo_base->base.SetParameters(fapo_base, pParameters, ParameterByteSize);
}
void CXAPOParametersBase::GetParameters(void* pParameters, UINT32 ParameterByteSize) {
assert(fapo_base->base.GetParameters);
fapo_base->base.GetParameters(fapo_base, pParameters, ParameterByteSize);
}
void CXAPOParametersBase::OnSetParameters(const void* pParameters, UINT32 ParameterByteSize)
{
assert(fapo_base->OnSetParameters);
fapo_base->OnSetParameters(fapo_base, pParameters, ParameterByteSize);
}
BOOL CXAPOParametersBase::ParametersChanged()
{
return FAPOBase_ParametersChanged(fapo_base);
}
BYTE* CXAPOParametersBase::BeginProcess()
{
return FAPOBase_BeginProcess(fapo_base);
}
void CXAPOParametersBase::EndProcess()
{
FAPOBase_EndProcess(fapo_base);
}