able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dplay/dvoice/dxvoice/mixserver.cpp

1212 lines
39 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*==========================================================================
*
* Copyright (C) 1999, 2000 Microsoft Corporation. All Rights Reserved.
*
* File: mixserver.cpp
* Content: Implements the mixing server portion of the server class
*
* History:
* Date By Reason
* ==== == ======
* 11/01/2000 rodtoll Split out from dvsereng.cpp
* 12/14/2000 rodtoll DPVOICE: [Mixing Server] Mixer may create infinite loop
* 02/20/2001 rodtoll WINBUG #321297 - DPVOICE: Access violation in DPVoice.dll while running DVSalvo server
* 04/09/2001 rodtoll WINBUG #364126 - DPVoice : Memory leak when Initializing 2 Voice Servers with same DPlay transport
*
***************************************************************************/
#include "dxvoicepch.h"
#define IsEmpty(x) (x.next == x.prev && x.next == &x)
//#define IsEmpty(x) (FALSE)
#define CONVERTTORECORD(x,y,z) ((y *)(x->pvObject))
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::AddPlayerToMixingAddList"
void CDirectVoiceServerEngine::AddPlayerToMixingAddList( CVoicePlayer *pPlayer )
{
CDVCSPlayer *pVoicePlayer = (CDVCSPlayer *) pPlayer;
DNASSERT( pVoicePlayer );
for( DWORD dwIndex = 0; dwIndex < m_dwNumMixingThreads; dwIndex++ )
{
DNEnterCriticalSection( &m_prWorkerControl[dwIndex].m_csMixingAddList );
pVoicePlayer->AddToMixingList( dwIndex, &m_prWorkerControl[dwIndex].m_blMixingAddPlayers );
pVoicePlayer->AddRef();
DNLeaveCriticalSection( &m_prWorkerControl[dwIndex].m_csMixingAddList );
}
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::StartWorkerThreads"
// StartWorkerThreads
//
// This function starts mixer worker threads. The number started is based on the
// m_dwNumMixingThreads variable which must be initialized before this is called.
//
HRESULT CDirectVoiceServerEngine::StartWorkerThreads()
{
HRESULT hr = DV_OK;
DWORD dwIndex;
m_prWorkerControl = new MIXERTHREAD_CONTROL[m_dwNumMixingThreads];
if( m_prWorkerControl == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Out of memory!" );
return DVERR_OUTOFMEMORY;
}
// Zero memory so everything is initialized.
ZeroMemory( m_prWorkerControl, sizeof( MIXERTHREAD_CONTROL )*m_dwNumMixingThreads );
for( dwIndex = 0; dwIndex < m_dwNumMixingThreads; dwIndex++ )
{
m_prWorkerControl[dwIndex].dwThreadIndex = dwIndex;
m_prWorkerControl[dwIndex].hThreadDone = CreateEvent( NULL, FALSE, FALSE, NULL );
m_prWorkerControl[dwIndex].hThreadDoWork = CreateEvent( NULL, FALSE, FALSE, NULL );
m_prWorkerControl[dwIndex].hThreadIdle = CreateEvent( NULL, FALSE, FALSE, NULL );
m_prWorkerControl[dwIndex].hThreadQuit = CreateEvent( NULL, FALSE, FALSE, NULL );
m_prWorkerControl[dwIndex].m_pServerObject = this;
InitBilink( &m_prWorkerControl[dwIndex].m_blMixingAddPlayers, NULL );
InitBilink( &m_prWorkerControl[dwIndex].m_blMixingActivePlayers, NULL );
if (!DNInitializeCriticalSection( &m_prWorkerControl[dwIndex].m_csMixingAddList ))
{
hr = DVERR_OUTOFMEMORY;
goto EXIT_ERROR;
}
if( m_prWorkerControl[dwIndex].hThreadDone == NULL ||
m_prWorkerControl[dwIndex].hThreadDoWork == NULL ||
m_prWorkerControl[dwIndex].hThreadIdle == NULL ||
m_prWorkerControl[dwIndex].hThreadQuit == NULL )
{
hr = GetLastError();
DPFX(DPFPREP, DVF_ERRORLEVEL, "Error creating events hr=0x%x", hr );
hr = DVERR_GENERIC;
goto EXIT_ERROR;
}
m_prWorkerControl[dwIndex].m_mixerBuffer = new BYTE[m_dwUnCompressedFrameSize];
m_prWorkerControl[dwIndex].m_realMixerBuffer = new LONG[m_dwMixerSize];
if( m_prWorkerControl[dwIndex].m_mixerBuffer == NULL ||
m_prWorkerControl[dwIndex].m_realMixerBuffer == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Error allocating memory" );
hr = DVERR_OUTOFMEMORY;
goto EXIT_ERROR;
}
m_prWorkerControl[dwIndex].hThread = (HANDLE) CreateThread( NULL, 0, MixerWorker, &m_prWorkerControl[dwIndex], 0, &m_prWorkerControl[dwIndex].dwThreadID );
if( m_prWorkerControl[dwIndex].hThread == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Error creating events/thread" );
hr = DVERR_GENERIC;
goto EXIT_ERROR;
}
::SetThreadPriority( m_prWorkerControl[dwIndex].hThread, THREAD_PRIORITY_TIME_CRITICAL );
}
return DV_OK;
EXIT_ERROR:
ShutdownWorkerThreads();
return hr;
}
HRESULT CDirectVoiceServerEngine::ShutdownWorkerThreads()
{
DWORD dwIndex;
if( m_prWorkerControl )
{
for( dwIndex = 0; dwIndex < m_dwNumMixingThreads; dwIndex++ )
{
if( m_prWorkerControl[dwIndex].hThread )
{
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "[%d]: Shutting down ID=[0x%x]", dwIndex, m_prWorkerControl[dwIndex].dwThreadID );
SetEvent( m_prWorkerControl[dwIndex].hThreadQuit );
WaitForSingleObject( m_prWorkerControl[dwIndex].hThreadDone, INFINITE );
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "[%d]: Shutting down complete", dwIndex );
CloseHandle( m_prWorkerControl[dwIndex].hThread );
m_prWorkerControl[dwIndex].hThread = NULL;
DNDeleteCriticalSection( &m_prWorkerControl[dwIndex].m_csMixingAddList );
}
if( m_prWorkerControl[dwIndex].hThreadDone )
CloseHandle( m_prWorkerControl[dwIndex].hThreadDone );
if( m_prWorkerControl[dwIndex].hThreadDoWork )
CloseHandle( m_prWorkerControl[dwIndex].hThreadDoWork );
if( m_prWorkerControl[dwIndex].hThreadIdle )
CloseHandle( m_prWorkerControl[dwIndex].hThreadIdle );
if( m_prWorkerControl[dwIndex].hThreadQuit )
CloseHandle( m_prWorkerControl[dwIndex].hThreadQuit );
if( m_prWorkerControl[dwIndex].m_mixerBuffer )
delete [] m_prWorkerControl[dwIndex].m_mixerBuffer;
if( m_prWorkerControl[dwIndex].m_realMixerBuffer )
delete [] m_prWorkerControl[dwIndex].m_realMixerBuffer;
DNASSERT( (IsEmpty( m_prWorkerControl[dwIndex].m_blMixingAddPlayers )) );
DNASSERT( (IsEmpty( m_prWorkerControl[dwIndex].m_blMixingActivePlayers )) );
}
delete [] m_prWorkerControl;
m_prWorkerControl = NULL;
}
return 0;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::StartupClientServer"
//
// StartupClientServer
//
// This function is called to initialize the Mixer portion of the server object.
// Only called for Mixing Sessions. Initialization includes the startup of
// the mixing thread and startup of the mixer multimedia timer.
//
// Called By:
// - StartSession
//
// Locks Required:
// - None
//
HRESULT CDirectVoiceServerEngine::StartupClientServer()
{
HRESULT hr;
HANDLE tmpThreadHandle;
SYSTEM_INFO sysInfo;
DWORD dwIndex;
m_pFramePool = NULL;
m_dwCompressedFrameSize = m_lpdvfCompressionInfo->dwFrameLength;
m_dwUnCompressedFrameSize = DVCDB_CalcUnCompressedFrameSize( m_lpdvfCompressionInfo, s_lpwfxMixerFormat );
m_dwNumPerBuffer = m_lpdvfCompressionInfo->dwFramesPerBuffer;
m_pFramePool = new CFramePool( m_dwCompressedFrameSize );
if( m_pFramePool == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to allocate frame pool" );
return DVERR_OUTOFMEMORY;
}
if (!m_pFramePool->Init())
{
delete m_pFramePool;
m_pFramePool = NULL;
return DVERR_OUTOFMEMORY;
}
m_mixerEightBit = (s_lpwfxMixerFormat->wBitsPerSample==8) ? TRUE : FALSE;
GetSystemInfo( &sysInfo );
m_dwNumMixingThreads = sysInfo.dwNumberOfProcessors;
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXER: There will be %d worker threads", m_dwNumMixingThreads );
if( m_mixerEightBit )
{
m_dwMixerSize = m_dwUnCompressedFrameSize;
}
else
{
// Mixer size is / 2 because 16-bit samples, only need 1 LONG for
// each 16-bit sample = 2 * 8bit.
m_dwMixerSize = m_dwUnCompressedFrameSize / 2;
}
m_pStats->m_dwNumMixingThreads = m_dwNumMixingThreads;
hr = StartWorkerThreads();
if( FAILED( hr ) )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed starting worker threads hr=0x%x", hr );
goto EXIT_CLIENTSERVERSTARTUP;
}
// General info
m_timer = new Timer;
if( m_timer == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Out of memory!" );
hr = DVERR_OUTOFMEMORY;
goto EXIT_CLIENTSERVERSTARTUP;
}
m_hTickSemaphore = CreateSemaphore( NULL, 0, 0xFFFFFF, NULL );
if( m_hTickSemaphore == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create semaphore" );
hr = DVERR_GENERIC;
goto EXIT_CLIENTSERVERSTARTUP;
}
m_hShutdownMixerEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
m_hMixerDoneEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
if( m_hShutdownMixerEvent == NULL ||
m_hMixerDoneEvent == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create events" );
hr = DVERR_GENERIC;
goto EXIT_CLIENTSERVERSTARTUP;
}
m_hMixerControlThread = CreateThread( NULL, 0, MixerControl, this, 0, &m_dwMixerControlThreadID );
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXER: Controller Started: ID=0x%x", m_dwMixerControlThreadID );
if( m_hMixerControlThread == NULL )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Error creating events/thread" );
hr = DVERR_GENERIC;
goto EXIT_CLIENTSERVERSTARTUP;
}
::SetThreadPriority( m_hMixerControlThread, THREAD_PRIORITY_TIME_CRITICAL );
if( !m_timer->Create( m_lpdvfCompressionInfo->dwTimeout, 2, (DWORD_PTR) &m_hTickSemaphore, MixingServerWakeupProc ) )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create multimedia timer" );
hr = DVERR_GENERIC;
goto EXIT_CLIENTSERVERSTARTUP;
}
return DV_OK;
EXIT_CLIENTSERVERSTARTUP:
ShutdownClientServer();
return hr;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::ShutdownClientServer"
//
// ShutdownClientServer
//
// This function is responsible for shutting down the mixer portion of the
// server object. This function should only be called for mixing sessions.
//
// This function will stop the mixer thread and the mixer multimedia timer.
//
// Called By:
// - StopSession
//
// Locks Required:
// - None
//
HRESULT CDirectVoiceServerEngine::ShutdownClientServer()
{
if( m_hMixerControlThread )
{
SetEvent( m_hShutdownMixerEvent );
WaitForSingleObject( m_hMixerDoneEvent, INFINITE );
CloseHandle( m_hMixerControlThread );
m_hMixerControlThread = NULL;
// Cleanup the mixing list
CleanupMixingList();
}
if( m_hShutdownMixerEvent )
{
CloseHandle( m_hShutdownMixerEvent );
m_hShutdownMixerEvent = NULL;
}
if( m_hMixerDoneEvent )
{
CloseHandle( m_hMixerDoneEvent );
m_hMixerDoneEvent = NULL;
}
ShutdownWorkerThreads();
if( m_timer )
{
delete m_timer;
m_timer = NULL;
}
if( m_hTickSemaphore )
{
CloseHandle( m_hTickSemaphore );
m_hTickSemaphore = NULL;
}
return DV_OK;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::Mixer_Buffer_Reset"
// Mixer_Buffer_Reset
//
// This function resets the mixer buffer back to silence.
void CDirectVoiceServerEngine::Mixer_Buffer_Reset( DWORD dwThreadIndex )
{
FillBufferWithSilence( m_prWorkerControl[dwThreadIndex].m_realMixerBuffer,
m_prWorkerControl[dwThreadIndex].m_pServerObject->m_mixerEightBit,
m_prWorkerControl[dwThreadIndex].m_pServerObject->m_dwUnCompressedFrameSize );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::Mixer_Buffer_MixBuffer"
// Mixer_Buffer_MixBuffer
//
// This function mixes the speech pointed to by the source parameter
// into the mixer buffer.
//
// Parameters:
// unsigned char *source -
// Pointer to source data in uncompressed format
void CDirectVoiceServerEngine::Mixer_Buffer_MixBuffer( DWORD dwThreadIndex, unsigned char *source )
{
MixInBuffer( m_prWorkerControl[dwThreadIndex].m_realMixerBuffer, source,
m_prWorkerControl[dwThreadIndex].m_pServerObject->m_mixerEightBit,
m_prWorkerControl[dwThreadIndex].m_pServerObject->m_dwUnCompressedFrameSize );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::Mixer_Buffer_Normalize"
// Mixer_Buffer_Normalize
//
// This function takes the mixed audio data from the mixer
// buffer and transfers it back to the mixer format
// and places it into the m_mixerBuffer buffer.
//
void CDirectVoiceServerEngine::Mixer_Buffer_Normalize( DWORD dwThreadIndex )
{
NormalizeBuffer( m_prWorkerControl[dwThreadIndex].m_mixerBuffer,
m_prWorkerControl[dwThreadIndex].m_realMixerBuffer,
m_prWorkerControl[dwThreadIndex].m_pServerObject->m_mixerEightBit,
m_prWorkerControl[dwThreadIndex].m_pServerObject->m_dwUnCompressedFrameSize );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::HandleMixerThreadError"
//
// HandleMixerThreadError
//
// This function is called by the mixer when an unrecoverable error
// occurs.
//
void CDirectVoiceServerEngine::HandleMixerThreadError( HRESULT hr )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Mixer Thread Encountered an error. hr=0x%x", hr );
SetEvent( m_hMixerDoneEvent );
StopSession( 0, FALSE, hr );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::MixerControl"
DWORD WINAPI CDirectVoiceServerEngine::MixerControl( void *pvContext )
{
CDirectVoiceServerEngine *This = (CDirectVoiceServerEngine *) pvContext;
HANDLE hEvents[3];
HANDLE *hIdleEvents = new HANDLE[This->m_dwNumMixingThreads+1];
DWORD dwIndex = 0;
LONG lFreeThreadIndex = 0;
DWORD dwNumToMix = 0;
DWORD dwTickCountStart;
LONG lWaitResult;
if( !hIdleEvents )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "MIXCTRL: Error allocating array" );
DNASSERT( FALSE );
SetEvent( This->m_hMixerDoneEvent );
return 0;
}
hEvents[0] = This->m_hShutdownMixerEvent;
hEvents[1] = This->m_hTickSemaphore;
hEvents[2] = (HANDLE) ((DWORD_PTR) 0xFFFFFFFF);
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXCTRL: Starting up" );
for( dwIndex = 0; dwIndex < This->m_dwNumMixingThreads; dwIndex++ )
{
hIdleEvents[dwIndex] = This->m_prWorkerControl[dwIndex].hThreadIdle;
}
hIdleEvents[This->m_dwNumMixingThreads] = (HANDLE) ((DWORD_PTR) 0xFFFFFFFF);
// Wait for tick or for quit command
while( (lWaitResult = WaitForMultipleObjects( 2, hEvents, FALSE, INFINITE )) != WAIT_OBJECT_0 )
{
// On Win9X we may occationally over run the end of the wait list
// and the result is we hit the FFFFFFFFF which will cause
// a failure.
if( lWaitResult == WAIT_FAILED )
continue;
// Update statistics block
InterlockedIncrement( &This->m_pStats->m_dwNumMixingPasses );
dwTickCountStart = GetTickCount();
// On Win95 you may occasionally encounter a situation where the waitformultiple runs
// off the end of the list and ends up with the invalid handle above. Just continue
// in this case.
lFreeThreadIndex = WAIT_FAILED;
while( lFreeThreadIndex == WAIT_FAILED )
{
// Wait for a single mixing thread to be free
lFreeThreadIndex = WaitForMultipleObjects( This->m_dwNumMixingThreads, hIdleEvents, FALSE, INFINITE );
//// TODO: Error checking!
}
lFreeThreadIndex -= WAIT_OBJECT_0;
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXCTRL: Worker [%d] is elected to do work", lFreeThreadIndex );
This->SpinWorkToThread( lFreeThreadIndex );
}
delete [] hIdleEvents;
SetEvent( This->m_hMixerDoneEvent );
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXCTRL: Shutting down" );
return 0;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::MixerWorker"
DWORD WINAPI CDirectVoiceServerEngine::MixerWorker( void *pvContext )
{
PMIXERTHREAD_CONTROL This = (PMIXERTHREAD_CONTROL) pvContext;
HANDLE hEvents[3];
BILINK *pblSearch, *pblSubSearch;
CDVCSPlayer *pCurrentPlayer = NULL, *pTmpPlayer = NULL;
PDVID pdvidTargets = NULL;
DWORD dwNumTargets = 0;
DWORD dwTargetIndex = 0;
DWORD dwResultSize = 0;
DWORD dwIndex = 0;
DWORD dwThreadIndex = This->dwThreadIndex;
HRESULT hr;
CDVCSPlayer **ppThreadHearList = NULL;
PDVPROTOCOLMSG_SPEECHHEADER pdvmSpeechHeader = NULL;
PDVTRANSPORT_BUFFERDESC pdvbTransmitBufferDesc = NULL;
PVOID pvSendContext = NULL;
DVID dvidSendTarget;
DWORD dwTickCountStart;
DWORD dwTickCountDecStart;
DWORD dwTickCountMixStart;
DWORD dwTickCountDupStart;
DWORD dwTickCountRetStart;
DWORD dwStatIndex;
DWORD dwTickCountEnd;
DWORD dwTotalMix, dwForwardMix, dwReuseMix, dwOriginalMix;
LONG lWaitResult;
MixingServerStats *pStats = This->m_pServerObject->m_pStats;
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXWORKER: [%d] Started [0x%x] Thread", This->dwThreadIndex, GetCurrentThreadId() );
hEvents[0] = This->hThreadQuit;
hEvents[1] = This->hThreadDoWork;
hEvents[2] = (HANDLE) ((DWORD_PTR) 0xFFFFFFFF);
SetEvent( This->hThreadIdle );
while( (lWaitResult = WaitForMultipleObjects( 2, hEvents, FALSE, INFINITE )) != WAIT_OBJECT_0 )
{
// On Win95 it may occationally move off the end of the list and hit the guard value
if( lWaitResult == WAIT_FAILED )
continue;
// Statistics update
dwTickCountStart = GetTickCount();
InterlockedIncrement( &pStats->m_dwNumMixingThreadsActive );
pStats->m_dwNumMixingPassesPerThread[dwThreadIndex]++;
if( pStats->m_dwNumMixingThreadsActive >
pStats->m_dwMaxMixingThreadsActive )
{
pStats->m_dwMaxMixingThreadsActive = pStats->m_dwNumMixingThreadsActive;
}
dwStatIndex = pStats->m_dwCurrentMixingHistoryLoc[dwThreadIndex];
pStats->m_lCurrentPlayerCount[dwThreadIndex][dwStatIndex] = This->dwNumToMix;
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXWORKER: [%d] Starting work", This->dwThreadIndex );
if( This->dwNumToMix == 0 )
{
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXWORKER: No players to process!" );
goto WORK_COMPLETE;
}
dwTickCountDecStart = GetTickCount();
pStats->m_lCurrentDecCountHistory[dwThreadIndex][dwStatIndex] = 0;
// Pass through player list and decompress those who need decompression
//
pblSearch = This->m_blMixingSpeakingPlayers.next;
while( pblSearch != &This->m_blMixingSpeakingPlayers )
{
pCurrentPlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_blMixingSpeakingPlayers[dwThreadIndex] );
// Dereference the array of can hear players for this player
ppThreadHearList = pCurrentPlayer->m_pppCanHear[dwThreadIndex];
// Player needs to have their voice decompressed
if( pCurrentPlayer->m_pfNeedsDecompression[dwThreadIndex] )
{
DNASSERT( pCurrentPlayer );
DNASSERT( pCurrentPlayer->m_pSourceFrame[dwThreadIndex] );
DNASSERT( !pCurrentPlayer->m_pSourceFrame[dwThreadIndex]->GetIsSilence() );
dwResultSize = This->m_pServerObject->m_dwUnCompressedFrameSize;
hr = pCurrentPlayer->DeCompressInBound(
pCurrentPlayer->m_pSourceFrame[dwThreadIndex],
&pCurrentPlayer->m_sourceUnCompressed[pCurrentPlayer->m_pdwUnCompressedBufferOffset[dwThreadIndex]],
&dwResultSize );
pStats->m_lCurrentDecCountHistory[dwThreadIndex][dwStatIndex]++;
if( FAILED( hr ) )
{
DNASSERT( FALSE );
// TODO: ERROR Handling for failed decompression
}
else
{
pCurrentPlayer->m_pfDecompressed[dwThreadIndex] = TRUE;
}
DNASSERT( dwResultSize == This->m_pServerObject->m_dwUnCompressedFrameSize );
}
// Integrity checks
//
// Check to ensure that each player who this person can hear is supposed to be decompressed
#ifdef _DEBUG
DNASSERT( pCurrentPlayer->m_pdwHearCount[dwThreadIndex] < This->dwNumToMix );
if( pCurrentPlayer->m_pdwHearCount[dwThreadIndex] > 1 )
{
for( dwIndex; dwIndex < pCurrentPlayer->m_pdwHearCount[dwThreadIndex]; dwIndex++ )
{
DNASSERT( ppThreadHearList[dwIndex] );
DNASSERT( ppThreadHearList[dwIndex]->m_pfNeedsDecompression[dwThreadIndex] );
}
}
#endif
pblSearch = pblSearch->next;
}
dwTickCountDupStart = GetTickCount();
pStats->m_lCurrentDecTimeHistory[dwThreadIndex][dwStatIndex] = dwTickCountDupStart - dwTickCountDecStart;
// Check for duplicates in the sending. If there is duplicates then we need
// to setup the reuse
pblSearch = This->m_blMixingHearingPlayers.next;
while( pblSearch != &This->m_blMixingHearingPlayers )
{
pCurrentPlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_blMixingHearingPlayers[dwThreadIndex] );
// If we don't hear anybody, this step is irrelevant
if( pCurrentPlayer->m_pdwHearCount[dwThreadIndex] < 2 )
goto DUPLICATE_CHECK_LOOP_DONE;
// Dereference the array of can hear players for this player
ppThreadHearList = pCurrentPlayer->m_pppCanHear[dwThreadIndex];
pblSubSearch = This->m_blMixingHearingPlayers.next;
// Only do the people who come before them.
while( pblSubSearch != pblSearch )
{
pTmpPlayer = CONVERTTORECORD( pblSubSearch, CDVCSPlayer, m_blMixingHearingPlayers[dwThreadIndex] );
// This person's mix is the same, re-use it!
if( pTmpPlayer->ComparePlayerMix( dwThreadIndex, pCurrentPlayer ) )
{
pCurrentPlayer->m_pReuseMixFromThisPlayer[dwThreadIndex] = pTmpPlayer;
pTmpPlayer->m_pfMixToBeReused[dwThreadIndex] = TRUE;
break;
}
pblSubSearch = pblSubSearch->next;
}
DUPLICATE_CHECK_LOOP_DONE:
pblSearch = pblSearch->next;
}
dwTickCountMixStart = GetTickCount();
pStats->m_lCurrentDupTimeHistory[dwThreadIndex][dwStatIndex] = dwTickCountMixStart - dwTickCountDupStart;
dwTotalMix = 0;
dwForwardMix = 0;
dwReuseMix = 0;
dwOriginalMix = 0;
// Pass through player list and compress and send mixes as appropriate
pblSearch = This->m_blMixingHearingPlayers.next;
while( pblSearch != &This->m_blMixingHearingPlayers )
{
pCurrentPlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_blMixingHearingPlayers[dwThreadIndex] );
// Dereference the array of can hear players for this player
ppThreadHearList = pCurrentPlayer->m_pppCanHear[dwThreadIndex];
// Pre-set next so we can continue() below and still go to next item
pblSearch = pblSearch->next;
if( !pCurrentPlayer->m_pdwHearCount[dwThreadIndex] )
{
continue;
}
dwTotalMix++;
// Get a transmission buffer and description
pdvbTransmitBufferDesc = This->m_pServerObject->GetTransmitBuffer( This->m_pServerObject->m_dwCompressedFrameSize+sizeof(DVPROTOCOLMSG_SPEECHHEADER)+COMPRESSION_SLUSH,
&pvSendContext );
if( pdvbTransmitBufferDesc == NULL )
{
// TODO: Error handling for out of memory condition
DNASSERT( FALSE );
}
// Setup the packet header
pdvmSpeechHeader = (PDVPROTOCOLMSG_SPEECHHEADER) pdvbTransmitBufferDesc->pBufferData;
pdvmSpeechHeader->dwType = DVMSGID_SPEECHBOUNCE;
pdvmSpeechHeader->bMsgNum = pCurrentPlayer->m_pbMsgNumToSend[dwThreadIndex];
pdvmSpeechHeader->bSeqNum = pCurrentPlayer->m_pbSeqNumToSend[dwThreadIndex];
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXWORKER: [%d] Sending Packet to 0x%x Msg=0x%x Seq=0x%x",
dwThreadIndex,
pCurrentPlayer->GetPlayerID(),
pdvmSpeechHeader->bMsgNum,
pdvmSpeechHeader->bSeqNum );
// If this player hears something they will be getting a packet
//
// Only hear one person -- forward the packet
//
if( pCurrentPlayer->m_pdwHearCount[dwThreadIndex] == 1)
{
dwResultSize = ppThreadHearList[0]->m_pSourceFrame[dwThreadIndex]->GetFrameLength();
memcpy( &pdvmSpeechHeader[1],
ppThreadHearList[0]->m_pSourceFrame[dwThreadIndex]->GetDataPointer(),
dwResultSize );
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXWORKER: [%d] Forwarding already compressed packet", dwThreadIndex );
pCurrentPlayer->m_pfMixed[dwThreadIndex] = TRUE;
dwForwardMix++;
}
else if( pCurrentPlayer->m_pdwHearCount[dwThreadIndex] > 1)
{
pTmpPlayer = pCurrentPlayer->m_pReuseMixFromThisPlayer[dwThreadIndex];
// We are re-using a previous player's mix
if( pTmpPlayer )
{
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXERWORKER: [%d] Forwarding pre-built mix", dwThreadIndex );
DNASSERT( pTmpPlayer->m_pfMixed[dwThreadIndex] );
DNASSERT( pTmpPlayer->m_pfMixToBeReused[dwThreadIndex] );
DNASSERT( pTmpPlayer->m_pdwResultLength[dwThreadIndex] );
dwResultSize = pTmpPlayer->m_pdwResultLength[dwThreadIndex];
memcpy( &pdvmSpeechHeader[1],
&pTmpPlayer->m_targetCompressed[pTmpPlayer->m_pdwCompressedBufferOffset[dwThreadIndex]],
dwResultSize );
dwReuseMix++;
}
else
{
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXERWORKER: [%d] Creating original mix", dwThreadIndex );
dwOriginalMix++;
dwResultSize = This->m_pServerObject->m_dwCompressedFrameSize;
// Reset the high resolution mixer buffer
This->m_pServerObject->Mixer_Buffer_Reset(dwThreadIndex);
// Mix in specified player's audio.
for( dwIndex = 0; dwIndex < pCurrentPlayer->m_pdwHearCount[dwThreadIndex]; dwIndex++ )
{
DNASSERT( !ppThreadHearList[dwIndex]->m_pfSilence[dwThreadIndex] );
This->m_pServerObject->Mixer_Buffer_MixBuffer(dwThreadIndex,ppThreadHearList[dwIndex]->m_sourceUnCompressed );
}
// Normalize the buffer back to the thread's mix buffer
This->m_pServerObject->Mixer_Buffer_Normalize(dwThreadIndex);
hr = pCurrentPlayer->CompressOutBound( This->m_mixerBuffer,
This->m_pServerObject->m_dwUnCompressedFrameSize,
(BYTE *) &pdvmSpeechHeader[1],
&dwResultSize );
if( FAILED( hr ) )
{
DNASSERT( FALSE );
DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed compressing outbound audio" );
}
pCurrentPlayer->m_pfMixed[dwThreadIndex] = TRUE;
pCurrentPlayer->m_pdwResultLength[dwThreadIndex] = dwResultSize;
// This player's mix will be re-used, ensure that we cache it
if( pCurrentPlayer->m_pfMixToBeReused[dwThreadIndex] )
{
memcpy( &pCurrentPlayer->m_targetCompressed[pCurrentPlayer->m_pdwCompressedBufferOffset[dwThreadIndex]],
&pdvmSpeechHeader[1],
pCurrentPlayer->m_pdwResultLength[dwThreadIndex] );
}
}
}
else
{
DNASSERT(FALSE);
}
dvidSendTarget = pCurrentPlayer->GetPlayerID();
pdvbTransmitBufferDesc->dwBufferSize= dwResultSize + sizeof( DVPROTOCOLMSG_SPEECHHEADER );
hr = This->m_pServerObject->m_lpSessionTransport->SendToIDS( &dvidSendTarget, 1, pdvbTransmitBufferDesc, pvSendContext, 0 );
if( hr == DVERR_PENDING )
hr = DV_OK;
if( FAILED( hr ) )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "MIXWORKER: [%d] Unable to transmit to target [0x%x]", pCurrentPlayer->GetPlayerID() );
}
}
dwTickCountRetStart = GetTickCount();
pStats->m_lCurrentMixTimeHistory[dwThreadIndex][dwStatIndex] = dwTickCountRetStart - dwTickCountMixStart;
pStats->m_lCurrentMixCountTotalHistory[dwThreadIndex][dwStatIndex] = dwTotalMix;
pStats->m_lCurrentMixCountFwdHistory[dwThreadIndex][dwStatIndex] = dwForwardMix;
pStats->m_lCurrentMixCountReuseHistory[dwThreadIndex][dwStatIndex] = dwReuseMix;
pStats->m_lCurrentMixCountOriginalHistory[dwThreadIndex][dwStatIndex] = dwOriginalMix;
WORK_COMPLETE:
// Pass through player list and return frames
pblSearch = This->m_blMixingActivePlayers.next;
while( pblSearch != &This->m_blMixingActivePlayers )
{
pCurrentPlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_pblMixingActivePlayers[dwThreadIndex] );
DNASSERT( pCurrentPlayer->m_pSourceFrame[dwThreadIndex] );
pCurrentPlayer->CompleteRun( dwThreadIndex );
pblSearch = pblSearch->next;
}
dwTickCountEnd = GetTickCount();
pStats->m_lCurrentRetTimeHistory[dwThreadIndex][dwStatIndex] = dwTickCountEnd - dwTickCountRetStart;
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXWORKER: [%d] Work complete", This->dwThreadIndex );
// Statistics update
InterlockedDecrement( &This->m_pServerObject->m_pStats->m_dwNumMixingThreadsActive );
SetEvent( This->hThreadIdle );
// Statistics update
pStats->m_dwMixingPassesTimeHistory[dwThreadIndex][dwStatIndex] = dwTickCountEnd - dwTickCountStart;
pStats->m_dwCurrentMixingHistoryLoc[dwThreadIndex]++;
pStats->m_dwCurrentMixingHistoryLoc[dwThreadIndex] %= MIXING_HISTORY;
}
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "MIXWORKER: [%d] Shutting down", This->dwThreadIndex );
SetEvent( This->hThreadDone );
return 0;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::SpinWorkToThread"
//
// SpinWorkToThread
//
// This function performs the first step of a mixing server pass and then
// passes the work off to the specified thread
//
// Responsible for:
// 1. Updating the
// 2. running the list of players, determinging who they can hear
//
void CDirectVoiceServerEngine::SpinWorkToThread( LONG lThreadIndex )
{
BILINK *pblSearch = NULL, *pblSubSearch = NULL;
CDVCSPlayer *pCurrentPlayer = NULL, *pTmpPlayer = NULL, *pComparePlayer = NULL;
HRESULT hr;
PDVID pdvidTargets = NULL;
DWORD dwNumTargets = 0;
DWORD dwTargetIndex = 0;
DWORD dwTickCountStart = GetTickCount();
// Update the list of players from the pending lists to the individual bilinks
UpdateActiveMixingPendingList( lThreadIndex, &m_prWorkerControl[lThreadIndex].dwNumToMix );
InitBilink( &m_prWorkerControl[lThreadIndex].m_blMixingSpeakingPlayers, NULL );
InitBilink( &m_prWorkerControl[lThreadIndex].m_blMixingHearingPlayers, NULL );
// Pass 1 through player list.
//
// Reset state variables for specified thread, create any converters that need creating
pblSearch = m_prWorkerControl[lThreadIndex].m_blMixingActivePlayers.next;
while( pblSearch != &m_prWorkerControl[lThreadIndex].m_blMixingActivePlayers )
{
pTmpPlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_pblMixingActivePlayers[lThreadIndex] );
pblSearch = pblSearch->next;
// Reset for the next pass
pTmpPlayer->ResetForNextRun(lThreadIndex,TRUE);
// Resize the can hear array
pTmpPlayer->ResizeIfRequired( lThreadIndex, m_prWorkerControl[lThreadIndex].dwNumToMix );
// Lock the player -- only one person should be creating converter at a time
pTmpPlayer->Lock();
// Create outbound converter if required
if( !pTmpPlayer->IsOutBoundConverterInitialized() )
{
hr = pTmpPlayer->CreateOutBoundConverter( s_lpwfxMixerFormat, m_dvSessionDesc.guidCT );
if( FAILED( hr ) )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to create outbound converter hr=0x%x", hr );
DNASSERT( FALSE );
}
}
// Create inbound converter if required
if( !pTmpPlayer->IsInBoundConverterInitialized() )
{
hr = pTmpPlayer->CreateInBoundConverter( m_dvSessionDesc.guidCT, s_lpwfxMixerFormat );
if( FAILED( hr ) )
{
DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to create converter" );
DNASSERT( FALSE );
}
}
pTmpPlayer->UnLock();
}
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "SST: 2" );
// Pass 2.
//
// For each player:
// 1. Figure out who they hear.
// 2. TODO: If they hear anyone, add them to the "to send to" list of people
// 3. TODO: If they hear > 1, add the people they hear to the "to decompress" list of people.
// 4. Setup the appropriate sequence # / msg # for the transmission
//
pblSearch = m_prWorkerControl[lThreadIndex].m_blMixingActivePlayers.next;
while( pblSearch != &m_prWorkerControl[lThreadIndex].m_blMixingActivePlayers )
{
pCurrentPlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_pblMixingActivePlayers[lThreadIndex] );
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "0x%x Can hear: ", pCurrentPlayer->GetPlayerID() );
pblSearch = pblSearch->next;
pblSubSearch = m_prWorkerControl[lThreadIndex].m_blMixingActivePlayers.next;
// Search the list of people in the session
while( pblSubSearch != &m_prWorkerControl[lThreadIndex].m_blMixingActivePlayers )
{
pComparePlayer = CONVERTTORECORD( pblSubSearch, CDVCSPlayer, m_pblMixingActivePlayers[lThreadIndex] );
pblSubSearch = pblSubSearch->next;
// This record contains a silent record -- ignore
if( pComparePlayer->m_pfSilence[lThreadIndex] )
continue;
// If this isn't the player themselves
if( pblSearch != pblSubSearch )
{
DNASSERT( pComparePlayer->m_pSourceFrame[lThreadIndex] );
pdvidTargets = pComparePlayer->m_pSourceFrame[lThreadIndex]->GetTargetList();
dwNumTargets = pComparePlayer->m_pSourceFrame[lThreadIndex]->GetNumTargets();
// The target of the subIndex user's frame is this user OR
// The user is in the group which is target of subIndex user's frame
for( dwTargetIndex = 0; dwTargetIndex < dwNumTargets; dwTargetIndex++ )
{
if( pCurrentPlayer->GetPlayerID() == pdvidTargets[dwTargetIndex] ||
m_lpSessionTransport->IsPlayerInGroup( pdvidTargets[dwTargetIndex], pCurrentPlayer->GetPlayerID() ) )
{
*((*(pCurrentPlayer->m_pppCanHear+lThreadIndex))+pCurrentPlayer->m_pdwHearCount[lThreadIndex]) = pComparePlayer;
pCurrentPlayer->m_pdwHearCount[lThreadIndex]++;
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "0x%x", pComparePlayer->GetPlayerID() );
// Setup the appropriate msg num / sequence number so when it's sent
// we ensure it gets re-assembled on the other side in the right order
if( pCurrentPlayer->m_pdwHearCount[lThreadIndex] == 1 )
{
if( pCurrentPlayer->m_bLastSent == FALSE )
{
pCurrentPlayer->m_bMsgNum++;
pCurrentPlayer->m_bSeqNum = 0;
pCurrentPlayer->m_bLastSent = TRUE;
}
else
{
pCurrentPlayer->m_bSeqNum++;
}
pCurrentPlayer->m_pbMsgNumToSend[lThreadIndex] = pCurrentPlayer->m_bMsgNum;
pCurrentPlayer->m_pbSeqNumToSend[lThreadIndex] = pCurrentPlayer->m_bSeqNum;
pCurrentPlayer->AddToHearingList( lThreadIndex, &m_prWorkerControl[lThreadIndex].m_blMixingHearingPlayers );
}
// We can hear > 1 person, we need to mark each person as needing decompression
else if( pCurrentPlayer->m_pdwHearCount[lThreadIndex] > 1 )
{
if( !pComparePlayer->m_pfNeedsDecompression[lThreadIndex] )
{
// Add this player to the list of people who need to be decompressed
pComparePlayer->AddToSpeakingList( lThreadIndex, &m_prWorkerControl[lThreadIndex].m_blMixingSpeakingPlayers );
pComparePlayer->m_pfNeedsDecompression[lThreadIndex] = TRUE;
}
// Special case, we just transitioned to having > 1 people heard by this player,
// we should mark the first person we can hear for decompression as well
if( pCurrentPlayer->m_pdwHearCount[lThreadIndex] == 2 )
{
pTmpPlayer = (pCurrentPlayer->m_pppCanHear[lThreadIndex])[0];
if( !pTmpPlayer->m_pfNeedsDecompression[lThreadIndex] )
{
pTmpPlayer->AddToSpeakingList( lThreadIndex, &m_prWorkerControl[lThreadIndex].m_blMixingSpeakingPlayers );
pTmpPlayer->m_pfNeedsDecompression[lThreadIndex] = TRUE;
}
}
}
// We need to break out of the loop as we only need to add an individual player once to the
// list of people a player can hear.
break;
}
}
}
}
if( !pCurrentPlayer->m_pdwHearCount[lThreadIndex] )
{
pCurrentPlayer->m_bLastSent = FALSE;
}
else
{
pCurrentPlayer->m_bLastSent = TRUE;
}
}
m_pStats->m_dwPreMixingPassTimeHistoryLoc++;
m_pStats->m_dwPreMixingPassTimeHistoryLoc %= MIXING_HISTORY;
m_pStats->m_dwPreMixingPassTimeHistory[m_pStats->m_dwPreMixingPassTimeHistoryLoc] = GetTickCount() - dwTickCountStart;
SetEvent( m_prWorkerControl[lThreadIndex].hThreadDoWork );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::MixingServerWakeupProc"
// MixingServerWakeupProc
//
// This function is called by the windows timer used by this
// class each time the timer goes off. The function signals
// a semaphore provided by the creator of the timer.
//
// Parameters:
// DWORD param - A recast pointer to a HANDLE
BOOL CDirectVoiceServerEngine::MixingServerWakeupProc( DWORD_PTR param )
{
HANDLE *semaphore = (HANDLE *) param;
ReleaseSemaphore( *semaphore, 1, NULL );
return TRUE;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::HandleMixingReceive"
HRESULT CDirectVoiceServerEngine::HandleMixingReceive( CDVCSPlayer *pTargetPlayer, PDVPROTOCOLMSG_SPEECHWITHTARGET pdvSpeechWithtarget, DWORD dwSpeechSize, PBYTE pSourceSpeech )
{
HRESULT hr;
DPFX(DPFPREP, DVF_MIXER_DEBUG_LEVEL, "Mixing Server Speech Handler" );
hr = pTargetPlayer->HandleMixingReceive( &pdvSpeechWithtarget->dvHeader, pSourceSpeech, dwSpeechSize, (PDVID) &pdvSpeechWithtarget[1], pdvSpeechWithtarget->dwNumTargets );
DPFX(DPFPREP, DVF_CLIENT_SEQNUM_DEBUG_LEVEL, "SEQ: Receive: Msg [%d] Seq [%d]", pdvSpeechWithtarget->dvHeader.bMsgNum, pdvSpeechWithtarget->dvHeader.bSeqNum );
return hr;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::UpdateActiveMixingPendingList"
void CDirectVoiceServerEngine::UpdateActiveMixingPendingList( DWORD dwThreadIndex, DWORD *pdwNumActive)
{
BILINK *pblSearch;
CDVCSPlayer *pVoicePlayer;
DNEnterCriticalSection( &m_prWorkerControl[dwThreadIndex].m_csMixingAddList );
// Add players who are pending
pblSearch = m_prWorkerControl[dwThreadIndex].m_blMixingAddPlayers.next;
while( pblSearch != &m_prWorkerControl[dwThreadIndex].m_blMixingAddPlayers )
{
pVoicePlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_pblMixingActivePlayers[dwThreadIndex] );
pVoicePlayer->RemoveFromMixingList(dwThreadIndex);
pVoicePlayer->AddToMixingList( dwThreadIndex, &m_prWorkerControl[dwThreadIndex].m_blMixingActivePlayers );
pblSearch = m_prWorkerControl[dwThreadIndex].m_blMixingAddPlayers.next;
}
DNASSERT( (IsEmpty( m_prWorkerControl[dwThreadIndex].m_blMixingAddPlayers) ) );
DNLeaveCriticalSection( &m_prWorkerControl[dwThreadIndex].m_csMixingAddList );
*pdwNumActive = 0;
// Remove players who have disconnected
pblSearch = m_prWorkerControl[dwThreadIndex].m_blMixingActivePlayers.next;
while( pblSearch != &m_prWorkerControl[dwThreadIndex].m_blMixingActivePlayers )
{
pVoicePlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_pblMixingActivePlayers[dwThreadIndex] );
pblSearch = pblSearch->next;
// If current player has disconnected, remove them from active list
// and release the reference the list has
if( pVoicePlayer->IsDisconnected() )
{
pVoicePlayer->RemoveFromMixingList(dwThreadIndex);
pVoicePlayer->Release();
}
else
{
(*pdwNumActive)++;
}
}
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CleanupMixingList"
void CDirectVoiceServerEngine::CleanupMixingList()
{
BILINK *pblSearch;
CDVCSPlayer *pVoicePlayer;
for( DWORD dwIndex = 0; dwIndex < m_dwNumMixingThreads; dwIndex++ )
{
DNEnterCriticalSection( &m_prWorkerControl[dwIndex].m_csMixingAddList );
// Add players who are pending
pblSearch = m_prWorkerControl[dwIndex].m_blMixingAddPlayers.next;
while( pblSearch != &m_prWorkerControl[dwIndex].m_blMixingAddPlayers )
{
pVoicePlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_pblMixingActivePlayers[dwIndex] );
pblSearch = pblSearch->next;
pVoicePlayer->RemoveFromMixingList(dwIndex);
pVoicePlayer->Release();
}
DNLeaveCriticalSection( &m_prWorkerControl[dwIndex].m_csMixingAddList );
DNASSERT( (IsEmpty(m_prWorkerControl[dwIndex].m_blMixingAddPlayers )) );
pblSearch = m_prWorkerControl[dwIndex].m_blMixingActivePlayers.next;
while( pblSearch != &m_prWorkerControl[dwIndex].m_blMixingActivePlayers )
{
pVoicePlayer = CONVERTTORECORD( pblSearch, CDVCSPlayer, m_pblMixingActivePlayers[dwIndex] );
pblSearch = pblSearch->next;
pVoicePlayer->RemoveFromMixingList(dwIndex);
pVoicePlayer->Release();
}
}
}
Reference in a new issue Copy permalink