bool CMemoryStack::InitPhysical( unsigned size, unsigned alignment )
{
m_bPhysical = true;
m_maxSize = m_commitSize = size;
m_alignment = AlignValue( alignment, 4 );
int flags = PAGE_READWRITE;
if ( size >= 16*1024*1024 )
{
flags |= MEM_16MB_PAGES;
}
else
{
flags |= MEM_LARGE_PAGES;
}
m_pBase = (unsigned char *)XPhysicalAlloc( m_maxSize, MAXULONG_PTR, 4096, flags );
Assert( m_pBase );
m_pNextAlloc = m_pBase;
m_pCommitLimit = m_pBase + m_maxSize;
m_pAllocLimit = m_pBase + m_maxSize;
MemAlloc_RegisterExternalAllocation( CMemoryStack, GetBase(), GetSize() );
return ( m_pBase != NULL );
}
void CX360SmallBlockPool::Init( unsigned nBlockSize )
{
if ( !gm_pPhysicalBlock )
{
gm_pPhysicalBase = (byte *)XPhysicalAlloc( BYTES_X360_SBH, MAXULONG_PTR, 4096, PAGE_READWRITE | MEM_16MB_PAGES );
gm_pPhysicalLimit = gm_pPhysicalBase + BYTES_X360_SBH;
gm_pPhysicalBlock = gm_pPhysicalBase;
}
if ( !( nBlockSize % MIN_SBH_ALIGN == 0 && nBlockSize >= MIN_SBH_BLOCK && nBlockSize >= sizeof(TSLNodeBase_t) ) )
DebuggerBreak();
m_nBlockSize = nBlockSize;
m_pCurBlockEnd = m_pNextAlloc = NULL;
m_CommittedSize = 0;
}
ALvoid alGenStream( ALvoid )
{
assert(!s_pState->m_Stream.m_Valid);
// describe the stream
XBOXADPCMWAVEFORMAT wav;
_wavSetFormat(&wav, AL_FORMAT_STEREO4, 44100);
DSSTREAMDESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.dwMaxAttachedPackets = QAL_MAX_STREAM_PACKETS;
desc.lpwfxFormat = (WAVEFORMATEX*)&wav;
// create a voice for the stream
if (s_pState->m_SoundObject->CreateSoundStream(&desc,
&s_pState->m_Stream.m_pVoice, NULL) != DS_OK)
{
s_pState->m_Error = AL_OUT_OF_MEMORY;
return;
}
// get some memory to hold the stream data
s_pState->m_Stream.m_pPacketBuffer =
XPhysicalAlloc(QAL_MAX_STREAM_PACKETS * QAL_STREAM_PACKET_SIZE,
MAXULONG_PTR, 0, PAGE_READWRITE | PAGE_NOCACHE);
// setup some defaults
s_pState->m_Stream.m_Gain = 1.f;
s_pState->m_Stream.m_GainDirty = true;
s_pState->m_Stream.m_CurrentPacket = 0;
for (int p = 0; p < QAL_MAX_STREAM_PACKETS; ++p)
{
s_pState->m_Stream.m_PacketStatus[p] = XMEDIAPACKET_STATUS_SUCCESS;
}
s_pState->m_Stream.m_Open = false;
s_pState->m_Stream.m_Playing = false;
s_pState->m_Stream.m_Valid = true;
// setup a thread to service the stream (keep blocking IO out
// of the main thread)
s_pState->m_Stream.m_QueueLen = CreateSemaphore(NULL, 0, 256, NULL);
s_pState->m_Stream.m_Mutex = CreateMutex(NULL, FALSE, NULL);
s_pState->m_Stream.m_Thread = CreateThread(NULL, 0,
_streamThread, NULL, 0, NULL );
}
VOID* ResourceDatabase::PhysicalAlloc( DWORD dwSize, DWORD dwAlignment, DWORD dwFlags )
{
VOID* pBuf = XPhysicalAlloc( dwSize, MAXULONG_PTR, dwAlignment, dwFlags );
m_PhysicalAllocations.push_back( pBuf );
return pBuf;
}
ZED_UINT32 Model::Load( const char *p_pFilename )
{
HANDLE ModelFile = ZED_NULL;
ModelFile = CreateFile( p_pFilename, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, ZED_NULL );
if( ModelFile == ZED_NULL )
{
zedTrace( "Failed to load model: %s\n", p_pFilename );
return ZED_FAIL;
}
// TEMP!
// Don't care about the header's correctness
SetFilePointer( ModelFile, 87, ZED_NULL, FILE_CURRENT );
// !TEMP
// Get the amount of vertices to process
ZED_UINT64 RawVertCount = 0;
DWORD ReadIn = 0;
ReadFile( ModelFile, &RawVertCount, sizeof( ZED_UINT64 ), &ReadIn, NULL );
ZED_UINT64 VertCount = ( ( RawVertCount/4 )/3 )/2;
m_pVertexData = ( LPVERTEX_V1 )malloc( VertCount*sizeof( VERTEX_V1 ) );/*XPhysicalAlloc(
VertCount*sizeof( VERTEX_V1 ),
MAXULONG_PTR, 0, PAGE_READWRITE );*/
ReadFile( ModelFile, m_pVertexData, VertCount*sizeof( VERTEX_V1 ),
&ReadIn, NULL );
if( ReadIn != VertCount*sizeof( VERTEX_V1 ) )
{
zedTrace( "[ERROR] Failed to read the vertex data for %s\n",
p_pFilename );
return ZED_FAIL;
}
// Skip over the indices and face normal header
SetFilePointer( ModelFile, 12, ZED_NULL, FILE_CURRENT );
// NOT WORKING!!
ZED_UINT64 RawFaceCount = 0; // Should be 268272 for GraveGuy.zed
ReadFile( ModelFile, &RawFaceCount, sizeof( ZED_UINT64 ), &ReadIn, NULL );
ZED_UINT64 FaceCount = ( RawFaceCount/12 )/3;
m_pFaceData = ( LPFACE_V1 )malloc( sizeof( LPFACE_V1 )*FaceCount );/*XPhysicalAlloc(
sizeof( ZED_UINT16 )*FaceCount, MAXULONG_PTR,
MAXULONG_PTR, PAGE_READWRITE );*/
ReadFile( ModelFile, m_pFaceData, sizeof( FACE_V1 )*FaceCount, &ReadIn, NULL );
if( ReadIn != sizeof( FACE_V1 )*FaceCount )
{
zedTrace( "[ERROR] Failed to read the face data for %s\n",
p_pFilename );
}
CloseHandle( ModelFile );
// Set up the index and vertex buffers
m_pVertexBuffer = new IDirect3DVertexBuffer8( );
m_pIndexBuffer = new IDirect3DIndexBuffer8( );
XGSetVertexBufferHeader( 0, 0, 0, 0, m_pVertexBuffer, 0 );
void *pVertData = XPhysicalAlloc( RawVertCount, MAXULONG_PTR, MAXULONG_PTR, PAGE_READWRITE );
m_pVertexBuffer->Register( pVertData );
memcpy( pVertData, m_pVertexData, RawVertCount );
XGSetIndexBufferHeader( 0, 0, D3DFMT_INDEX16, 0, m_pIndexBuffer, 0 );
return ZED_OK;
}
/*
===============
SNDDMA_Init
===============
*/
int Q3_XAudio2Init(void)
{
HRESULT hr;
XAUDIO2_DEVICE_DETAILS deviceDetails;
WAVEFORMATEX wfx = {};
if (snd_inited)
return true;
// create audio on thread 4 or 5
if ( FAILED(hr = XAudio2Create( &pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR ) ) ) {
return false;
}
pXAudio2->GetDeviceDetails(0, &deviceDetails);
if ( FAILED(hr = pXAudio2->CreateMasteringVoice( &pMasterVoice, XAUDIO2_DEFAULT_CHANNELS,
XAUDIO2_DEFAULT_SAMPLERATE, 0, 0, NULL ) ) ) {
return false;
}
//memcpy(&wfx, &deviceDetails.OutputFormat.Format, sizeof(WAVEFORMATEX));
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = 2;
wfx.wBitsPerSample = 16;
//wfx.nSamplesPerSec = 48000;
wfx.nSamplesPerSec = 22050;
wfx.nBlockAlign = wfx.nChannels * wfx.wBitsPerSample/ 8;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
if( FAILED(hr = pXAudio2->CreateSourceVoice( &pSourceVoice, (WAVEFORMATEX*)&wfx,
0, XAUDIO2_DEFAULT_FREQ_RATIO, &Xaudio2Callback, NULL, NULL ) ) ) {
return false;
}
Com_Printf( "XAudio2 Init..." );
Com_Printf( "OK\n" );
dmapos = 0;
dma.samplebits = wfx.wBitsPerSample; // first byte of format is bits.
dma.channels = wfx.nChannels;
dma.samples = wfx.nAvgBytesPerSec/(dma.samplebits/8);
dma.submission_chunk = 1;
dma.speed = wfx.nSamplesPerSec;
//dmasize = (dma.samples * (dma.samplebits/8));
dmasize = wfx.nAvgBytesPerSec;
dma.buffer = (byte*)XPhysicalAlloc(dmasize, MAXULONG_PTR, 2048,PAGE_READWRITE);
xaudio_buffer_size = wfx.nAvgBytesPerSec / 2;
Xaudio2Buffer.AudioBytes = xaudio_buffer_size;
Xaudio2Buffer.pAudioData = (BYTE*)dma.buffer;
pSourceVoice->SubmitSourceBuffer( &Xaudio2Buffer );
pSourceVoice->Start( 0, XAUDIO2_COMMIT_NOW );
snd_inited = true;
return true;
}
