|
|
/*==========================================================================
* * Copyright (C) 1999 Microsoft Corporation. All Rights Reserved. * * File: dvclientengine.cpp * Content: Implementation of class for DirectXVoice Client * * History: * Date By Reason * ==== == ====== * 07/19/99 rodtoll Created * 07/21/99 rodtoll Added settings confirm message to protocol * Added storing user flags * 07/22/99 rodtoll Updated to use new player class * Improved concurrency protection * Added client/server support * 07/23/99 rodtoll Added multicast support * Modified notify loop, now checks for multicast timeouts * Modified playback loop to kill timed-out users * Minor fixes to client/server support * Other bugfixes. * Removed valid target check in multicast and client/server * 07/26/99 rodtoll Updated to support IDirectXVoiceNotify interface * 07/29/99 pnewson Updated call to CInputQueue2 constructor * 07/29/99 rodtoll Removed warnings, updated for new queue, added better * parameter checking. * 07/30/99 rodtoll Updated InitializeSound to use the parameters passed * in through the sounddeviceconfig. * 08/02/99 rodtoll Fixed bug in record volume * 08/03/99 pnewson Cleanup of Frame and Queue classes * 08/03/99 rodtoll Fixed calls into the transport * 08/04/99 rodtoll Fixed up Get/SetClientConfig * Added pointer to SoundConfig for second param of connect result * Half duplex clients won't get record level notifications anymore * Added connect result when error on connect * Modified so that soundeviceconfig gets ptr to dsound/dsc devices * Fixed bug w/sensitivity setting * 08/05/99 rodtoll Fixed locking, was causing deadlock w/DirectPlay * 08/10/99 rodtoll Initial support for host migration * rodtoll No longer creates a queue for ourselves * 08/18/99 rodtoll Fixed bug w/multicast. Added support for SPEECHBOUNCE * message type. * 08/25/99 rodtoll General Cleanup/Modifications to support new * compression sub-system. * 08/26/99 rodtoll Added copy of flags when doing SetClientConfig * rodtoll Fixed playback thread to properly handle playback mute * 08/27/99 rodtoll Fixed record start/stop notifications target info * rodtoll Added playervoicestart and playervoice stop messages * 08/30/99 rodtoll Fixed disconnect when sound init fails * Fixed disconnect when compression type unsupported * Fixed notification intervals * Added timeouts to connect and disconnect processes * Fixed bug in disconnect code * Added re-transmission of connect request * Fixed host migration notifications * Fixed return code on GetCompressionTypes call. * Updated to use new format specifications on playback * 08/31/99 rodtoll Logic re-write to fix shutdown problems. * - Notify thread now starts as soon as Initialize called * and stops when object destroyed * - Disconnect based on Disconnectconfirm or loss of * connection signals event, notify thread then handles * - Updated playback format to use 8Khz for playback * 09/01/99 rodtoll Added check for valid pointers in func calls * 09/02/99 rodtoll Added checks to handle case no local player created * Re-activated and fixed old auto record volume code * 09/03/99 rodtoll Re-work of playback core to support mixing to multiple buffers * for 3d support. * Re-worked playback to use position instead of notifications * allows for simpler handling of high CPU and 3d support * Implemented CreateUserBuffer/DeleteUserBuffer * 09/04/99 rodtoll Added code to delete 3d buffers for users/groups when they * are destroyed. * 09/07/99 rodtoll Added support for server controlled target message * rodtoll Added support for set/get user buffer for notarget * rodtoll Fixed InitHalfDuplex call -- was defaulting to default device always * 09/07/99 rodtoll Placed some guards to fix crash when Releasing when not initialized * 09/07/99 rodtoll Updated to allow buffer management on buffer for remaining users (main buffer) * rodtoll Updated return codes to use new errors (3d related) * 09/08/99 rodtoll Fixed playback level checking. * 09/10/99 rodtoll Implemented the DVCLIENTCONFIG_MUTEGLOBAL flag * rodtoll Additional parameter validations * 09/13/99 rodtoll Added preliminary support for new DVSOUNDDEVICECONFIG structure * 09/14/99 rodtoll Added new DVMSGID_PLAYEROUTPUTLEVEL message * rodtoll Added new SetNotifyMask function * rodtoll Updated INiitalize parameters to take notification masks. * rodtoll Implemented notification masks. (Allows user to choose which notifications to receive) * rodtoll Added CheckShouldSendMessage * rodtoll Added SendPlayerLevels (DVMSGID_PLAYEROUTPUTLEVEL messages handler) * 09/15/99 rodtoll Added DVMSGID_SETTARGET message when target is set by remote server * 09/16/99 rodtoll Updated Disconnect to alllow async and sync abortions of connects * 09/17/99 rodtoll Fixed bug in recordthread in error handling * 09/18/99 rodtoll Added HandleThreadError to be called when an internal thread dies. * 09/20/99 rodtoll Updated to return SESSIONLOST message instead of DISCONNECT when session is lost * rodtoll Functions will return DVERR_SESSIONLOST if called after session is lost. * rodtoll Improved error checking in playback thread * rodtoll Added more checks for memory alloc failures * rodtoll Small bugfix in playeroutputlevel messages * rodtoll Stricter checks on valid notify arrays * rodtoll Added proper error checking to SetNotifyMask * 09/27/99 rodtoll Fixed playback volume control * rodtoll Fixed bug w/echo servers w/clients running on same dvid as host * 09/28/99 rodtoll Fixed playervoicestart/stop notifications, now send source in the dwFrom param. * rodtoll Double notifications of local client when host migrates fixed. * rodtoll Added queue for notifications, notifications are added to the queue and * then signalled by the notify thread. (Prevents problems caused by notify * handlers taking a long time to return). * rodtoll Added voice suppression * 09/29/99 pnewson Major AGC overhaul * 10/04/99 rodtoll Added usage of the DVPROTOCOL_VERSION_XXX macros * rodtoll Added comments * rodtoll Fixed crash which occurs if object released before initialized * 10/05/99 rodtoll Added guards to DoDisconnect. If recording locked up on shutdown, then * DoDisconnect would be called twice --> Crash! Fixed. * rodtoll Reversed order of recording/playback shutdown. Shutting down playback * before recording caused recording lockup on ESS cards. * rodtoll Additional documentation * 10/07/99 rodtoll Updated to work in Unicode * rodtoll Modified notifications so connectresult should always be first * Removed release of write locks so that connect result would be queued first. * 10/15/99 pnewson Added config check in Connect call * 10/18/99 rodtoll Fix: Calling initialize twice doesn't fail. * 10/19/99 rodtoll Fix: Bug #113904 Shutdown Issues * - Added handler for SESSIONLOST messages. Fixes shutdown lockup. * - Changed disconnectAck event to manual reset so multiple threads can wait * on it. Neccessary to ensure disconnect is completed before release is done * - Changed behaviour of disconnect so that if you specify SYNC and disconnect * is in progress, you wait for complete. Required to support disconnect in releae * 10/25/99 rodtoll Fix: Bug #114684 - GetCaps causes lockup on shutdown * rodtoll Fix: Bug #114223 - Debug messages being printed at error level when inappropriate * 10/27/99 pnewson Fix: Bug #113935 - Saved AGC values should be device specific * Fix: Bug #113936 - Wizard should reset the AGC level before loopback test * Note: this fix adds the DVCLIENTCONFIG_AUTOVOLUMERESET flag * 10/28/99 pnewson Bug #114176 updated DVSOUNDDEVICECONFIG struct * 10/29/99 rodtoll Bug #113726 - Integrate Voxware Codecs, updating to use new * pluggable codec architecture. In order to support new architecture * all codecs creates were moved to threads where CoInitialize has been called. * rodtoll Fixed memory leak in multicast mode caused by new architecture * 11/04/99 pnewson Bug #114297 - Added HWND to SupervisorCheckAudioSetup call * 11/12/99 rodtoll Updated to use new playback and record classes and remove * old playback/record system (Includes waveIN/waveOut support) * rodtoll Updated to support new recording thread * rodtoll Added new echo suppression code * 11/16/99 rodtoll Recording thread now loops everytime it wakes up until it * has compressed and transmitted all the data it can before * going back to sleep. * 11/17/99 rodtoll Fix: Bug #115538 - dwSize members of > sizeof struct were accepted * rodtoll Fix: Bug #115827 - Calling SetNotifyMask w/no callback should fail * rodtoll Fix: Bug #117442 - Calling Disconnect with invalid flags doesn't return DVERR_INVALIDFLAGS * rodtoll Fix: Bug #117447 - GetTransmitTarget has problems * rodtoll Fix: Bug #117177 - Calling Connect w/o voice session never returns * 11/18/99 rodtoll Updated to control echo cancellation switching code by define. * 11/22/99 rodtoll Fixed problem caused by switching on echo cancellation while talking * 11/22/99 rodtoll Fixed Initialize() would fail incorrectly * 11/23/99 rodtoll Updated Initialize/SetNotifyMask so error checking behaviour is consistant * 11/24/99 rodtoll Adjusted Set/GetTransmit Target so locks are released before calling into dplay * 11/30/99 pnewson Reworked default device mapping code * Adjusted some timing issues to make single stepping connect possible * 12/01/99 rodtoll Bug #121815 - Recording/playback may contain static. Updated to call functions * to set conversion quality setting to high. * rodtoll Bug #115783 - Always adjusts volume for default device. Fixed for Win2k, Win9x w/DX7 * Systems w/DX5 or none will use waveIN/waveOUT and will default to default device. * 12/02/99 rodtoll Bug #115783 - Will now use waveIN/waveOut object corresponding to specified GUID * on DX3 systems. * 12/06/99 rodtoll Bumped playback/record threads to time critical priority * 12/16/99 rodtoll Bug #117405 - 3D Sound APIs misleading - 3d sound apis renamed * The Delete3DSoundBuffer was re-worked to match the create * rodtoll Bug #122629 - Host migration broken in unusual configurations * Implemented new host migration scheme. * rodtoll Bug #121054 - DirectX 7.1 changes must be incorporated * rodtoll Implemented new DVPROTOCOLMSG_PLAYERLIST message to handle player table message. * rodtoll As part of new host migration, implemented proper handling of connection * rejected message (was broken, exposed by new host migration). * rodtoll Updated Disconnect to handle inability to contact server properly which * was resulting in an error message (when it should disconnect anyhow). * rodtoll Removed voice suppression * 01/10/00 pnewson AGC and VA tuning * 01/14/2000 rodtoll Updated for new speech packet types / packet handling * rodtoll Updated for new Get/SetTransmitTargets functions * rodtoll Added support for multiple targets * rodtoll Added use of fixed pool manager to manage memory for * notifications. * rodtoll Updated notifications to support messages with memory. * rodtoll Updated message handler calls to use new format * rodtoll Updated all notifications to use new message structures * rodtoll Updated Connect/Disconnect so that when DVFLAGS_SYNCH is * specified no completion messages will be sent. * rodtoll Added new API call GetSoundDeviceConfig * 01/21/2000 pnewson Changes in support of revised wizard UI * Allow concurrent AGC and user controlled volume * 01/24/2000 rodtoll Bug #129427: Calling Destroy3DSoundBuffer for player who has * already disconnected resulted in an incorrect DVERR_NOTBUFFERED * error code. * 01/27/2000 rodtoll Bug #129934 - Update Create3DSoundBuffer to take DSBUFFERDESC * 01/28/2000 rodtoll Bug #130465: Record Mute/Unmute must call YieldFocus() / ClaimFocus() * 02/01/2000 rodtoll Disable capture focus features - Bug #129457 * 02/08/2000 rodtoll Bug #131496 - Selecting DVTHRESHOLD_DEFAULT results in voice * never being detected * 02/15/2000 rodtoll Fixed Connect so mapping GUIDs doesn't stomp user structure * 02/17/2000 rodtoll Bug #133691 - Choppy audio - queue was not adapting * Added instrumentation * 03/28/2000 rodtoll Re-wrote nametable handling and locking -- more scalable * rodtoll Fixed pool for players * rodtoll Bilink of "active players" and "players to notify" allows for greater * concurrency (playback and notify threads don't need to lock entire * nametable while running. * 03/29/2000 rodtoll Bug #30957 - Made conversion quality slider setting optional -- new flag -- DVSOUNDCONFIG_SETCONVERSIONQUALITY * rodtoll Incorporated experimental playback handling w/lower priority and more frequent wakeup * rodtoll Instead of calling ConfirmValidEntity now checks nametable * 04/07/2000 rodtoll Bug #32179 - Prevent registration of > 1 interface * rodtoll Updated to use no copy sends, so handles pooling frames to be sent, proper * pulling of frames from pools and returns. * 04/19/2000 rodtoll Re-enabled capture focus behaviour / found not working on WDM, re-disabled. * rodtoll Bug #31106 - Handle sound devices w/no recording volume * Set DVSOUNDCONFIG_NORECVOLAVAILABLE flag on DVSOUNDDEVICECONFIG and do not * perform any volume sets when this flag is present * 04/20/2000 rodtoll Bug #31478 - Lockup in shutdown on client who has become new host -- ref count issue * 04/24/2000 rodtoll Bug #33228 - Compile error reported by davidkl * 04/27/2000 rodtoll Fix for host migration crash turned out to be sample bug, restoring. * rodtoll Fix for crash on Connect failed * 05/11/2000 rodtoll Bug #34852 Voice connection crashes after being in a session for a couple of minutes * 05/17/2000 rodtoll Bug #35110 Simultaneous playback of 2 voices results in distorted playback * 05/30/2000 rodtoll Bug #35476 Access violation in DPVOICE.DLL on host after client left * Host migration code was being fired because of DirectPlay8's nametable unwinding funcs. * 05/31/2000 rodtoll Bug #35860 - Fix VC6 compile errors for instrumented builds * rodtoll Bug #35794 - Setting targets to none results in leak. * 06/02/2000 rodtoll Moved host migration so it is keyed off voice message and transport messages. * More reliable this way. * 06/21/2000 rodtoll Bug #35767 - Implement ability for Dsound effects processing if dpvoice buffers * Updated Connect and Create3DSoundBuffer to take buffers instead of descriptions * rodtoll Bug #36820 - Host migrates to wrong client when server is shut down before host's client disconnects * Caused because client attempts to register new server when there is one already * rodtoll Bug #37045 - Race conditions prevent acknowledgement of new host * Added send when new host is elected of settingsconfirm message * 06/27/2000 rodtoll Fixed window where outstanding sends being returned after we have deregistered * Voice now waits for all outstanding voice sends to complete before shutting down * rodtoll Added COM abstraction * 06/28/2000 rodtoll Prefix Bug #38022 * 07/01/2000 rodtoll Bug #38280 - DVMSGID_DELETEVOICEPLAYER messages are being sent in non-peer to peer sessions * Nametable will now only unravel with messages if session is peer to peer. * rodtoll Bug #38316 - HOST MIGRATION - Player fails to get HOST_MIGRATED message * 07/09/2000 rodtoll Added signature bytes * 07/12/2000 rodtoll Bug #39117 - Access violation while running VoicePosition. Several issues: * - Allow Destroy3DBuffer during disconnect * - Move nametable cleanup to before freesoundbufferlist * - Fixed code so always remove from list on DeleteSoundTarget * - Removed unneeded logic * 07/12/2000 rodtoll Bug #31468 - Add diagnostic spew to logfile to show what is failing the HW Wizard * rodtoll Bug #32841 - Renable support for capture focus * 07/22/2000 rodtoll Bug #40284 - Initialize() and SetNotifyMask() should return invalidparam instead of invalidpointer * rodtoll Bug #40296, 38858 - Crashes due to shutdown race condition * Now ensures that all threads from transport have left and that * all notificatinos have been processed before shutdown is complete. * rodtoll Bug #39586 - Trap 14 in DPVVOX.DLL during session of voicegroup, adding guards for overwrites * 07/26/2000 rodtoll Bug #40676 - Forwarding server is broken * 07/31/2000 rodtoll Bug #40470 - SetClientConfig() with invalid flags returns INVALIDPARAM * 08/03/2000 rodtoll Bug #41457 - DPVOICE: need way to discover which specific dsound call failed when returning DVERR_SOUNDINITFAILURE * 08/08/2000 rodtoll Was missing a DNLeaveCriticalSection * 08/09/2000 rodtoll Bug #41936 - No voice session message instead of compression not supported * 08/21/2000 rodtoll Bug #41475 - DPVOICE: Lockup during shutdown when deleteplayer messages received * 08/22/2000 rodtoll Bug #43095 - DPVOICE: DVMSGID_GAINFOCUS and DVMSGID_LOSTFOCUS are not passing NULL message parameters * 08/28/2000 masonb Voice Merge: DNet FPOOLs use DNCRITICAL_SECTION, modified m_pBufferDescPool usage * 08/29/2000 rodtoll Bug #43668 - DPVOICE: Asserts when exiting DPVOICE session * 08/31/2000 rodtoll Bug #43804 - DVOICE: dwSensitivity structure member is confusing - should be dwThreshold * 08/31/2000 rodtoll Whistler Bug #171841 - Prefix Bug * 09/01/2000 masonb Modified PlaybackThread, RecordThread, and NotifyThread to call _endthread to clean up thread handles * 09/14/2000 rodtoll Bug #45001 - DVOICE: AV if client has targetted > 10 players * 09/26/2000 rodtoll Bug #45541 - DPVOICE: Client gets DVERR_TIMEOUT message when disconnecting * 09/28/2000 rodtoll Fix Again: Bug #45541 - DPVOICE: Client gets DVERR_TIMEOUT message when disconnecting (Server always confirms disconnect) * 10/05/2000 rodtoll Bug #46541 - DPVOICE: A/V linking to dpvoice.lib could cause application to fail init and crash * 11/16/2000 rodtoll Bug #40587 - DPVOICE: Mixing server needs to use multi-processors * 01/22/2001 rodtoll WINBUG #288437 - IA64 Pointer misalignment due to wire packets * 01/25/2001 rodtoll WINBUG #293197 - DPVOICE: Stress applications cannot tell the difference between out of memory/invalid device/other errors * 01/26/2001 rodtoll WINBUG #293197 - DPVOICE: [STRESS} Stress applications cannot tell difference between out of memory and internal errors. * Remap DSERR_OUTOFMEMORY to DVERR_OUTOFMEMORY instead of DVERR_SOUNDINITFAILURE. * Remap DSERR_ALLOCATED to DVERR_PLAYBACKSYSTEMERROR instead of DVERR_SOUNDINITFAILURE. * * 04/04/2001 rodtoll WINBUG #343428 - DPVOICE: Voice wizard's playback is very choppy. * rodtoll WINBUG #356124 - STRESS: DPVLPY7 broke when Initialize() failed due to being out of memory. * 04/02/2001 simonpow Bug #354859 Fixes for problems spotted by PREfast (hresult casting to bool and local variable hiding) * 04/06/2001 kareemc Added Voice Defense * 04/12/2001 kareemc WINBUG #360971 - Wizard Memory Leaks * 04/09/2001 rodtoll WINBUG #363804 DPVOICE: Race condition in shutdown causes disconnect to timeout if session is being shutdown concurrently. * 04/11/2001 rodtoll WINBUG #221494 DPVOICE: Capped the # of queued recording events to prevent multiple wakeups resulting in false lockup * detection * 04/12/2001 simonpow WINBUG #322454 Removed early unlock in RemovePlayer method and added * extra return code checking in DoConnectResponse * 04/21/2001 rodtoll MANBUG #50058 DPVOICE: VoicePosition: No sound for couple of seconds when position bars are moved * - Added StartMix() call when secondary buffers are created * - Added extra bit of debug spew, removed dead code * 04/21/2001 rodtoll (for Simonpow) * WINBUG #322454 DPVOICE: [STRESS] Connect() appears to be suceeding (returns S_OK) but connection is not established. * 09/05/2001 simonpow Bug #463972. Added constuct/destruct methods to initialisation * calls on m_fpPlayers for CVoicePlayer * 11/12/2001 simonpow Bug #482302 Missing a DNLeaveCriticalSection in Cleanup * 02/25/2002 rodtoll WINBUG #550017 - SECURITY: DPVOICE: Client could inject speech into remove clients output * - Confirm voice messages in forwarding sessions come from the server. * rodtoll WINBUG #550009 - SECURITY: DPVOICE: Potential corruption of voice client state * - Harden receive pathways: i.e. confirm message sources from server, confirm message makes * sense w.r.t session settings, tighten validation, prevent duplicate disconnects from executing. * rodtoll WINBUG #550124 - SECURITY: DPVOICE: Shared memory region with NULL DACL * - Pull statistics exporting code * 03/01/2002 simonpow Fixed FreeBuffers to ensure it doesn't deinitialise any fixed * pools that haven't been initialised * 05/01/2002 simonpow Ensured GUID passed to DVCDB_GetCompressionInfo is aligned * in HandleConnectAccept * 06/13/2002 simonpow BUG #59944 Switched over to using Threadpool based timers rather than multimedia ***************************************************************************/
#include "dxvoicepch.h"
extern HRESULT DVS_Create(LPDIRECTVOICESERVEROBJECT *piDVS);
// Use high priority for playback / record threads
#define __CORE_THREAD_PRIORITY_HIGH
// Disables the sound system
//#define __DISABLE_SOUND
// Forces full duplex mode
//#define __FORCEFULLDUPLEX
// # of ms of inactivity before a multicast user is considered to have
// timed-out.
#define DV_MULTICAST_USERTIMEOUT_PERIOD 300000
// # of ms of inactivity before an incoming audio stream is considered to
// have stopped. Used to determine when to send PLAYERVOICESTOP
// message.
#define PLAYBACK_RECEIVESTOP_TIMEOUT 500
// # of ms the notify thread sleeps without notification to wakeup
// and perform house cleaning.
#define DV_CLIENT_NOTIFYWAKEUP_TIMEOUT 100
// # of ms before a connect request is considered to have been lost
#define DV_CLIENT_CONNECT_RETRY_TIMEOUT 1250
// # of ms before we should timeout a connect request completely
#define DV_CLIENT_CONNECT_TIMEOUT 30000
// Maximum count notification semaphores can have
#define DVCLIENT_NOTIFY_MAXSEMCOUNT 0x0FFFFFFF
//// TODO: Needs tuning.
// # of ms to wait for disconnect reply from server before timing out.
#define DV_CLIENT_DISCONNECT_TIMEOUT 10000
#define DV_CLIENT_SRCQUALITY_INVALID ((DIRECTSOUNDMIXER_SRCQUALITY) 0xFFFFFFFF)
#define CLIENT_POOLS_NUM 3
#define CLIENT_POOLS_SIZE_MESSAGE (sizeof(DVPROTOCOLMSG_FULLMESSAGE))
#define CLIENT_POOLS_SIZE_PLAYERLIST DVPROTOCOL_PLAYERLIST_MAXSIZE
// DV_CLIENT_EMULATED_LEAD_ADJUST
//
// # of buffer's worth of lead ahead of read pointer allowable to write
// in playback buffer when buffer is emulated (additional, not total)
#define DV_CLIENT_EMULATED_LEAD_ADJUST 2
// DV_CLIENT_BASE_LEAD_MAX
//
// Maximum # of buffers lead to allow
#define DV_CLIENT_BASE_LEAD_MAX 2
// MixingWakeupProc
//
// This function is called by the DvTimer 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
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::MixingWakeupProc"
void CDirectVoiceClientEngine::MixingWakeupProc( void * pvUserData ){ TimerHandlerParam *pParam = (TimerHandlerParam *) pvUserData;
SetEvent( pParam->hPlaybackTimerEvent ); SetEvent( pParam->hRecordTimerEvent );
DNEnterCriticalSection( &pParam->csPlayCount ); pParam->lPlaybackCount++; DNLeaveCriticalSection( &pParam->csPlayCount );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CDirectVoiceClientEngine"
//
// Constructor
//
// Initializes object to uninitialized state. Must call Initialize succesfully before
// the object can be used (except GetCompressionTypes which can be called at any time).
//
CDirectVoiceClientEngine::CDirectVoiceClientEngine( DIRECTVOICECLIENTOBJECT *lpObject ): m_dwSignature(VSIG_CLIENTENGINE), m_lpFramePool(NULL), m_lpObject(lpObject), m_lpSessionTransport(NULL), m_lpUserContext(NULL), m_dvidServer(0), m_pTimer(NULL), m_bLastPeak(0), m_bLastTransmitted(FALSE), m_bMsgNum(0), m_bSeqNum(0), m_dwActiveCount(0), m_dwLastConnectSent(0), m_audioPlaybackBuffer(NULL), m_audioRecordDevice(NULL), m_audioPlaybackDevice(NULL), m_audioRecordBuffer(NULL), m_hRecordDone(NULL), m_hRecordTerminate(NULL), m_hPlaybackDone(NULL), m_hPlaybackTerminate(NULL), m_hConnectAck(NULL), m_dwCurrentState(DVCSTATE_NOTINITIALIZED), m_hrConnectResult(DVERR_GENERIC), m_hrOriginalConnectResult(DVERR_GENERIC), m_hrDisconnectResult(DV_OK), m_hDisconnectAck(NULL), m_hNotifyDone( NULL ), m_hNotifyTerminate( NULL ), m_hNotifyChange( NULL ), m_bLastPlaybackPeak( 0 ), m_lpdvServerMigrated(NULL), m_hNotifyDisconnect(NULL), m_hNotifyConnect(NULL), m_pFramePool(NULL), m_lpstGeneralBuffer(NULL), m_lpstBufferList(NULL), m_lpdwMessageElements(NULL), m_dwNumMessageElements(0), m_fSessionLost(FALSE), m_fLocalPlayerNotify(FALSE), m_lpNotifyList(NULL), m_hNewNotifyElement(NULL), m_dwHostOrderID(DVPROTOCOL_HOSTORDER_INVALID), m_pdvidTargets(NULL), m_dwNumTargets(0), m_dwTargetVersion(0), m_fConnectAsync(false), m_fDisconnectAsync(false), m_dwOriginalRecordQuality(DV_CLIENT_SRCQUALITY_INVALID), m_dwOriginalPlayQuality(DV_CLIENT_SRCQUALITY_INVALID), m_dwPlayActiveCount(0), m_fLocalPlayerAvailable(FALSE), m_fNotifyQueueEnabled(FALSE), m_hRecordThreadHandle(NULL), m_hPlaybackThreadHandle(NULL), m_dwMigrateHostOrderID(DVPROTOCOL_HOSTORDER_INVALID), m_pStatsBlob(NULL), m_fCritSecInited(FALSE), m_iPlayerListReceived(-1), m_fDisconnecting(FALSE){
m_dvSoundDeviceConfig.lpdsCaptureDevice = NULL; m_dvSoundDeviceConfig.lpdsPlaybackDevice = NULL;
memset( &m_dvCaps, 0x00, sizeof( DVCAPS ) ); m_dvCaps.dwSize = sizeof( DVCAPS ); m_dvCaps.dwFlags = 0;
ClientStats_Reset();}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::InitClass"
BOOL CDirectVoiceClientEngine::InitClass( ){ if (!DNInitializeCriticalSection( &m_csNotifyQueueLock )) { return FALSE; } if (!DNInitializeCriticalSection( &m_lockPlaybackMode )) { DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csTargetLock )) { DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csCleanupProtect )) { DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csBufferLock )) { DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csPlayAddList )) { DNDeleteCriticalSection( &m_csBufferLock ); DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csNotifyAddList )) { DNDeleteCriticalSection( &m_csPlayAddList ); DNDeleteCriticalSection( &m_csBufferLock ); DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csTransmitBufferLock )) { DNDeleteCriticalSection( &m_csNotifyAddList ); DNDeleteCriticalSection( &m_csPlayAddList ); DNDeleteCriticalSection( &m_csBufferLock ); DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_thTimerInfo.csPlayCount )) { DNDeleteCriticalSection( &m_csTransmitBufferLock ); DNDeleteCriticalSection( &m_csNotifyAddList ); DNDeleteCriticalSection( &m_csPlayAddList ); DNDeleteCriticalSection( &m_csBufferLock ); DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csClassLock )) { DNDeleteCriticalSection( &m_thTimerInfo.csPlayCount ); DNDeleteCriticalSection( &m_csTransmitBufferLock ); DNDeleteCriticalSection( &m_csNotifyAddList ); DNDeleteCriticalSection( &m_csPlayAddList ); DNDeleteCriticalSection( &m_csBufferLock ); DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } if (!DNInitializeCriticalSection( &m_csNotifyLock )) { DNDeleteCriticalSection( &m_csClassLock ); DNDeleteCriticalSection( &m_thTimerInfo.csPlayCount ); DNDeleteCriticalSection( &m_csTransmitBufferLock ); DNDeleteCriticalSection( &m_csNotifyAddList ); DNDeleteCriticalSection( &m_csPlayAddList ); DNDeleteCriticalSection( &m_csBufferLock ); DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); return FALSE; } m_fCritSecInited = TRUE; return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::~CDirectVoiceClientEngine"
// Destructor
//
// This function requires a write lock to complete.
//
// If the object is connected to a session, it will be disconnected
// by this function.
//
// Releases the resources associated with the object and stops the
// notifythread.
//
// Locks Required:
// - Class Write Lock
//
// Called By:
// DVC_Release when reference count reaches 0.
//
CDirectVoiceClientEngine::~CDirectVoiceClientEngine(){ CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
if( m_dwCurrentState != DVCSTATE_IDLE && m_dwCurrentState != DVCSTATE_NOTINITIALIZED ) { Cleanup(); }
if( m_hNotifyDone != NULL ) { SetEvent( m_hNotifyTerminate ); WaitForSingleObject( m_hNotifyDone, INFINITE );
CloseHandle( m_hNotifyDone ); CloseHandle( m_hNotifyTerminate ); CloseHandle( m_hNotifyChange ); CloseHandle( m_hNotifyDisconnect ); CloseHandle( m_hNotifyConnect ); m_hNotifyDone = NULL; m_hNotifyTerminate = NULL; m_hNotifyChange = NULL; m_hNotifyDisconnect = NULL; m_hNotifyConnect = NULL; }
if( m_hConnectAck != NULL ) CloseHandle( m_hConnectAck );
if( m_hDisconnectAck != NULL ) CloseHandle( m_hDisconnectAck );
if( m_lpdvServerMigrated != NULL ) { m_lpdvServerMigrated->Release(); m_lpdvServerMigrated = NULL; }
if( m_lpdwMessageElements != NULL ) delete [] m_lpdwMessageElements;
guardLock.Unlock();
NotifyQueue_Free();
if (m_fCritSecInited) { DNDeleteCriticalSection( &m_lockPlaybackMode ); DNDeleteCriticalSection( &m_csTargetLock ); DNDeleteCriticalSection( &m_csCleanupProtect ); DNDeleteCriticalSection( &m_csBufferLock ); DNDeleteCriticalSection( &m_thTimerInfo.csPlayCount ); DNDeleteCriticalSection( &m_csPlayAddList ); DNDeleteCriticalSection( &m_csNotifyAddList ); DNDeleteCriticalSection( &m_csTransmitBufferLock ); DNDeleteCriticalSection( &m_csClassLock ); DNDeleteCriticalSection( &m_csNotifyQueueLock ); DNDeleteCriticalSection( &m_csNotifyLock ); }
if( m_pdvidTargets != NULL ) { delete [] m_pdvidTargets; }
m_dwSignature = VSIG_CLIENTENGINE_FREE;}
// InternalSetNotifyMask
//
// Sets the list of valid notifiers for this object.
//
// Locks Needed:
// - ReadLock to check status and then releases it.
// - m_csNotifyLock to update notification list
//
// Called By:
// DVC_SetNotifyMask
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::InternalSetNotifyMask"
HRESULT CDirectVoiceClientEngine::InternalSetNotifyMask( LPDWORD lpdwMessages, DWORD dwNumElements ){ BFCSingleLock slLock( &m_csNotifyLock ); slLock.Lock();
// Delete previous elements
if( m_lpdwMessageElements != NULL ) { delete [] m_lpdwMessageElements; }
m_dwNumMessageElements = dwNumElements;
// Make copies of the message elements into our own message array.
if( dwNumElements > 0 ) { m_lpdwMessageElements = new DWORD[dwNumElements];
if( m_lpdwMessageElements == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Initialize: Error allocating memory" ); return DVERR_OUTOFMEMORY; }
memcpy( m_lpdwMessageElements, lpdwMessages, sizeof(DWORD)*dwNumElements ); } else { m_lpdwMessageElements = NULL; }
return DV_OK;
}
// SetNotifyMask
//
// Sets the list of valid notifiers for this object.
//
// Locks Needed:
// - ReadLock to check status and then releases it.
// - m_csNotifyLock to update notification list
//
// Called By:
// DVC_SetNotifyMask
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetNotifyMask"
HRESULT CDirectVoiceClientEngine::SetNotifyMask( LPDWORD lpdwMessages, DWORD dwNumElements ){ HRESULT hr;
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" );
hr = DV_ValidMessageArray( lpdwMessages, dwNumElements, FALSE );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "ValidMessageArray Failed 0x%x", hr ); return hr; } DPFX(DPFPREP, DVF_APIPARAM, "Message IDs=%d", dwNumElements ); if( lpdwMessages != NULL ) { for( DWORD dwIndex = 0; dwIndex < dwNumElements; dwIndex++ ) { DPFX(DPFPREP, DVF_APIPARAM, "MessageIDs[%d] = %d", dwIndex, lpdwMessages[dwIndex] ); } }
CDVCSLock guardLock(&m_csClassLock); guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not initialized" ); return DVERR_NOTINITIALIZED; }
guardLock.Unlock();
BFCSingleLock slLock( &m_csNotifyLock ); slLock.Lock();
if( m_lpMessageHandler == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Cannot specify message mask there is no callback function" ); return DVERR_NOCALLBACK; }
hr = InternalSetNotifyMask( lpdwMessages, dwNumElements );
DPFX(DPFPREP, DVF_APIPARAM, "Returning hr=0x%x", hr );
return DV_OK;}
// Initialize
//
// Initializes this object into a state where it can be used to Connect to a session. Sets the
// notification function, notification mask and the transport object that will be used.
//
// Starts the notification thread.
//
// Locks Required:
// - Class Write Lock
//
// Called By:
// DV_Initialize
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Initialize"
HRESULT CDirectVoiceClientEngine::Initialize( CDirectVoiceTransport *lpTransport, LPDVMESSAGEHANDLER lpdvHandler, LPVOID lpUserContext, LPDWORD lpdwMessages, DWORD dwNumElements ){ HRESULT hr;
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" );
// 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "Param: lpTransport = 0x%p lpdvHandler = 0x%p lpUserContext = 0x%p dwNumElements = %d", lpTransport, lpdvHandler, lpUserContext, dwNumElements );
if( lpTransport == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid transport" ); return DVERR_INVALIDPOINTER; }
hr = DV_ValidMessageArray( lpdwMessages, dwNumElements, FALSE );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "ValidMessageArray Failed hr = 0x%x", hr ); return hr; } DPFX(DPFPREP, DVF_APIPARAM, "Message IDs=%d", dwNumElements ); if( lpdwMessages != NULL ) { for( DWORD dwIndex = 0; dwIndex < dwNumElements; dwIndex++ ) { DPFX(DPFPREP, DVF_APIPARAM, "MessageIDs[%d] = %d", dwIndex, lpdwMessages[dwIndex] ); } }
HANDLE hThread;
// Wait for a write lock on the object
CDVCSLock guardLock(&m_csClassLock); guardLock.Lock();
if( m_dwCurrentState != DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Already Initialized" ); return DVERR_INITIALIZED; }
if( lpdvHandler == NULL && lpdwMessages != NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Cannot specify message mask there is no callback function" ); return DVERR_NOCALLBACK; }
m_dwLastConnectSent = 0; m_dwSynchBegin = 0; SetCurrentState( DVCSTATE_IDLE );
BFCSingleLock slLock( &m_csNotifyLock ); slLock.Lock();
m_lpMessageHandler = lpdvHandler;
hr = InternalSetNotifyMask( lpdwMessages, dwNumElements );
if( FAILED( hr ) ) { SetCurrentState( DVCSTATE_NOTINITIALIZED ); DPFX(DPFPREP, DVF_ERRORLEVEL, "SetNotifyMask Failed hr=0x%x", hr ); return hr; }
m_lpSessionTransport = lpTransport; m_lpUserContext = lpUserContext;
m_dvidLocal = 0; m_dwActiveCount = 0;
m_thTimerInfo.hPlaybackTimerEvent = NULL; m_thTimerInfo.lPlaybackCount = 0; m_thTimerInfo.hRecordTimerEvent = NULL;
m_hConnectAck = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hDisconnectAck = CreateEvent( NULL, TRUE, FALSE, NULL );
m_hNotifyDone = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hNotifyTerminate = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hNotifyChange = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hNotifyDisconnect = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hNotifyConnect = CreateEvent( NULL, FALSE, FALSE, NULL );
if( m_hConnectAck == NULL || m_hDisconnectAck == NULL || m_hNotifyTerminate == NULL || m_hNotifyChange == NULL || m_hNotifyDisconnect == NULL || m_hNotifyConnect == NULL || m_hNotifyDone==NULL) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create required events" ); goto ERROR_EXIT_INIT; }
if (FAILED(NotifyQueue_Init())) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to init notify queue" ); goto ERROR_EXIT_INIT; } hThread = (HANDLE) _beginthread( NotifyThread, 0, this );
if( hThread == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create watcher thread" ); goto ERROR_EXIT_INIT; } // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_INFOLEVEL, "Notify Thread Started: 0x%p", hThread );
guardLock.Unlock(); DPFX(DPFPREP, DVF_APIPARAM, "Returning DV_OK" ); return DV_OK; ERROR_EXIT_INIT:
if( m_hConnectAck != NULL ) { CloseHandle( m_hConnectAck ); m_hConnectAck = NULL; }
if( m_hDisconnectAck != NULL ) { CloseHandle( m_hDisconnectAck ); m_hDisconnectAck = NULL; } if( m_hNotifyTerminate != NULL ) { CloseHandle( m_hNotifyTerminate ); m_hNotifyTerminate = NULL; }
if( m_hNotifyChange != NULL ) { CloseHandle( m_hNotifyChange ); m_hNotifyChange = NULL; } if( m_hNotifyDisconnect != NULL ) { CloseHandle( m_hNotifyDisconnect ); m_hNotifyDisconnect = NULL; }
if( m_hNotifyConnect != NULL ) { CloseHandle( m_hNotifyConnect ); m_hNotifyConnect = NULL; }
DPFX(DPFPREP, DVF_ERRORLEVEL, "Returning DVERR_GENERIC" );
return DVERR_GENERIC;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Connect"
// Connect
//
// Implements the IDirectXVoiceClient::Connect function.
//
// Locks Required:
// - Write Lock
//
// Called By:
// DVC_Connect
//
HRESULT CDirectVoiceClientEngine::Connect( LPDVSOUNDDEVICECONFIG lpSoundDeviceConfig, LPDVCLIENTCONFIG lpClientConfig, DWORD dwFlags ){ HRESULT hr; DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" );
hr = DV_ValidClientConfig( lpClientConfig );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid Client Config hr=0x%x", hr ); return hr; }
hr = DV_ValidSoundDeviceConfig( lpSoundDeviceConfig, s_lpwfxPlaybackFormat );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid Sound Device Config hr=0x%x", hr ); return hr; }
if( dwFlags & ~(DVFLAGS_SYNC|DVFLAGS_NOQUERY) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid flags specified" ); return DVERR_INVALIDFLAGS; }
DV_DUMP_SDC( lpSoundDeviceConfig ); DV_DUMP_CC( lpClientConfig );
CDVCSLock guardLock(&m_csClassLock); guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Object not initialized" ); return DVERR_NOTINITIALIZED; }
if( m_dwCurrentState == DVCSTATE_CONNECTING || m_dwCurrentState == DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Already connecting or disconnecting" ); return DVERR_ALREADYPENDING; }
if( m_dwCurrentState == DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Already connected" ); return DVERR_CONNECTED; }
// Copy over the parameters
memcpy( &m_dvSoundDeviceConfig, lpSoundDeviceConfig, sizeof( DVSOUNDDEVICECONFIG ) );
// map the devices
GUID guidTemp; hr = DV_MapCaptureDevice(&(m_dvSoundDeviceConfig.guidCaptureDevice), &guidTemp); if (FAILED(hr)) { DPFX(DPFPREP, DVF_ERRORLEVEL, "DV_MapCaptureDevice failed, code: %i", hr); return hr; } m_dvSoundDeviceConfig.guidCaptureDevice = guidTemp; hr = DV_MapPlaybackDevice(&(m_dvSoundDeviceConfig.guidPlaybackDevice), &guidTemp); if (FAILED(hr)) { DPFX(DPFPREP, DVF_ERRORLEVEL, "DV_MapPlaybackDevice failed, code: %i", hr); return hr; } m_dvSoundDeviceConfig.guidPlaybackDevice = guidTemp;
// Check to ensure setup has been run on these devices
// but only if the NOQUERY flag has not been set.
if (!(dwFlags & DVFLAGS_NOQUERY)) { hr = SupervisorCheckAudioSetup( &(m_dvSoundDeviceConfig.guidPlaybackDevice), &(m_dvSoundDeviceConfig.guidCaptureDevice), NULL, DVFLAGS_QUERYONLY); switch (hr) { case DV_FULLDUPLEX: // great - carry on.
DPFX(DPFPREP, DVF_INFOLEVEL, "Devices have been tested - full duplex ok"); break; case DV_HALFDUPLEX: // force on the half duplex flag.
DPFX(DPFPREP, DVF_INFOLEVEL, "Devices have been tested - half duplex only"); m_dvSoundDeviceConfig.dwFlags |= DVSOUNDCONFIG_HALFDUPLEX; break;
case DVERR_SOUNDINITFAILURE: // The devices were tested, and failed miserably.
DPFX(DPFPREP, DVF_INFOLEVEL, "Devices have been tested - total failure"); return DVERR_SOUNDINITFAILURE; break; case DVERR_RUNSETUP: // return the run setup code
DPFX(DPFPREP, DVF_ERRORLEVEL, "Devices have not been tested"); return DVERR_RUNSETUP;
default: // unexpected return code - this is a real error - propogate it back up
DPFX(DPFPREP, DVF_ERRORLEVEL, "SupervisorCheckAudioSetup failed, code: %i", hr); return hr; } }
// RESET Session flags that need to be reset on every connect
m_fSessionLost = FALSE; m_hrDisconnectResult = DV_OK; m_fLocalPlayerNotify = FALSE; m_fLocalPlayerAvailable = FALSE; m_dwHostOrderID = DVPROTOCOL_HOSTORDER_INVALID; m_hPlaybackThreadHandle = NULL; m_hRecordThreadHandle = NULL; m_thTimerInfo.hPlaybackTimerEvent = NULL; m_thTimerInfo.lPlaybackCount = 0; m_thTimerInfo.hRecordTimerEvent = NULL; m_lpdvfCompressionInfo = NULL; m_hrConnectResult = DVERR_GENERIC; m_hrOriginalConnectResult = DVERR_GENERIC;
// Ok not to use interlocked functions as this should be only thread running w/voice
m_iPlayerListReceived = -1;
m_fDisconnecting = FALSE; ClientStats_Reset();
// Add a reference to incoming objects
if( m_dvSoundDeviceConfig.lpdsPlaybackDevice != NULL ) { m_dvSoundDeviceConfig.lpdsPlaybackDevice->AddRef(); }
if( m_dvSoundDeviceConfig.lpdsMainBuffer != NULL ) { m_dvSoundDeviceConfig.lpdsMainBuffer->AddRef(); }
// Add a reference to incoming objects
if( m_dvSoundDeviceConfig.lpdsCaptureDevice != NULL ) { m_dvSoundDeviceConfig.lpdsCaptureDevice->AddRef(); }
DNEnterCriticalSection( &m_lockPlaybackMode ); m_dwActiveCount = 0; m_dwEchoState = DVCECHOSTATE_IDLE; DNLeaveCriticalSection( &m_lockPlaybackMode );
// Need to reset disconnect event manually
ResetEvent( m_hDisconnectAck );
// This was here to disable capture
//
// m_dvSoundDeviceConfig.dwFlags |= DVSOUNDCONFIG_NOFOCUS;
m_dvSoundDeviceConfig.dwMainBufferFlags |= DSBPLAY_LOOPING;
memcpy( &m_dvClientConfig, lpClientConfig, sizeof( DVCLIENTCONFIG ) );
// Check for duplicate objects in the process, re-use existing object if there is one.
// Also does some sanity checks.
hr = CheckForDuplicateObjects();
if( FAILED(hr) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error checking dsound(cap) objects hr=0x%x", hr ); goto CONNECT_ERROR; }
#ifdef __FORCEFULLDUPLEX
m_dvSoundDeviceConfig.dwFlags |= DVSOUNDCONFIG_HALFDUPLEX;#endif
if( m_dvClientConfig.dwBufferAggressiveness == DVBUFFERAGGRESSIVENESS_DEFAULT ) { m_dvClientConfig.dwBufferAggressiveness = s_dwDefaultBufferAggressiveness; }
if( m_dvClientConfig.dwBufferQuality == DVBUFFERQUALITY_DEFAULT ) { m_dvClientConfig.dwBufferQuality = s_dwDefaultBufferQuality; }
if( m_dvClientConfig.dwThreshold == DVTHRESHOLD_DEFAULT ) { m_dvClientConfig.dwThreshold = s_dwDefaultSensitivity; }
m_dwMigrateHostOrderID = DVPROTOCOL_HOSTORDER_INVALID; m_dwLastConnectSent = 0; m_dwSynchBegin = 0; SetCurrentState( DVCSTATE_CONNECTING );
// Initialize the name table
m_voiceNameTable.Initialize();
// Initialize bilinks -- if we fail on our connect things won't go south.
m_dwPlayActiveCount = 0; m_blPlayActivePlayers.Initialize(); m_blPlayAddPlayers.Initialize(); m_blNotifyActivePlayers.Initialize(); m_blNotifyAddPlayers.Initialize();
m_pStatsBlob = &m_stats;
m_fpPlayers.Initialize(sizeof(CVoicePlayer), CVoicePlayer::PoolAllocFunction, NULL, NULL, CVoicePlayer::PoolDeallocFunction); hr = SetupInitialBuffers();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "SetupBuffersInitial Failed 0x%x", hr ); goto CONNECT_ERROR; }
hr = m_lpSessionTransport->EnableReceiveHook( m_lpObject, DVTRANSPORT_OBJECTTYPE_CLIENT );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "EnableReceiveHook Failed 0x%x", hr ); goto CONNECT_ERROR; }
m_fConnectAsync = !(dwFlags & DVFLAGS_SYNC);
m_dvidServer = m_lpSessionTransport->GetServerID(); m_dvidLocal = m_lpSessionTransport->GetLocalID();
// Send connect request to the server
guardLock.Unlock();
m_dwLastConnectSent = GetTickCount(); m_dwSynchBegin = m_dwLastConnectSent;
hr = Send_ConnectRequest(); DPFX(DPFPREP, DVF_INFOLEVEL, "DVCE::Connect() - Sending Request to server" );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error on send 0x%x", hr ); goto CONNECT_ERROR; }
// If the user wants us to wait for the response, wait here.
if( dwFlags & DVFLAGS_SYNC ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Sync flag, waiting for completion." );
// Wait until we're called with the appropriate message
WaitForSingleObject( m_hConnectAck, INFINITE ); DPFX(DPFPREP, DVF_INFOLEVEL, "Server response received" );
return GetConnectResult(); }
return DVERR_PENDING; CONNECT_ERROR:
// Release any objects we are holding.. if we have created a sound device
// reference. I.e. we've linked to an inproc sound object
if( lpSoundDeviceConfig->lpdsPlaybackDevice == NULL && m_dvSoundDeviceConfig.lpdsPlaybackDevice != NULL ) { m_dvSoundDeviceConfig.lpdsPlaybackDevice->Release(); m_dvSoundDeviceConfig.lpdsPlaybackDevice = NULL; }
if( m_dvSoundDeviceConfig.lpdsMainBuffer != NULL ) { m_dvSoundDeviceConfig.lpdsMainBuffer->Release(); m_dvSoundDeviceConfig.lpdsMainBuffer = NULL; }
// Release any objects we are holding
// i.e. we've linked to an inproc sound object
if( lpSoundDeviceConfig->lpdsCaptureDevice == NULL && m_dvSoundDeviceConfig.lpdsCaptureDevice != NULL ) { m_dvSoundDeviceConfig.lpdsCaptureDevice->Release(); m_dvSoundDeviceConfig.lpdsCaptureDevice = NULL; } SetCurrentState( DVCSTATE_IDLE ); FreeBuffers(); m_voiceNameTable.DeInitialize((m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_PEER),m_lpUserContext,m_lpMessageHandler); m_fpPlayers.DeInitialize();
return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Send_SessionLost"
HRESULT CDirectVoiceClientEngine::Send_SessionLost(){ PDVPROTOCOLMSG_SESSIONLOST pSessionLost; PDVTRANSPORT_BUFFERDESC pBufferDesc; LPVOID pvSendContext; HRESULT hr;
pBufferDesc = GetTransmitBuffer( sizeof( DVPROTOCOLMSG_SESSIONLOST ), &pvSendContext );
if( pBufferDesc == NULL ) { return DVERR_OUTOFMEMORY; }
pSessionLost = (PDVPROTOCOLMSG_SESSIONLOST) pBufferDesc->pBufferData;
// Send connection request to the server
pSessionLost->dwType = DVMSGID_SESSIONLOST; pSessionLost->hresReason = DVERR_SESSIONLOST; // Fixed so that it gets sent
hr = m_lpSessionTransport->SendToAll( pBufferDesc, pvSendContext, DVTRANSPORT_SEND_GUARANTEED );
if( hr != DVERR_PENDING && hr != DV_OK ) { DPFX(DPFPREP, 0, "Error sending connect request hr=0x%x", hr ); ReturnTransmitBuffer( pvSendContext ); } // Pending = OK = expected
else { hr = DV_OK; } return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Send_ConnectRequest"
HRESULT CDirectVoiceClientEngine::Send_ConnectRequest(){ PDVPROTOCOLMSG_CONNECTREQUEST pConnectRequest; PDVTRANSPORT_BUFFERDESC pBufferDesc; LPVOID pvSendContext; HRESULT hr;
pBufferDesc = GetTransmitBuffer( sizeof( DVPROTOCOLMSG_CONNECTREQUEST ), &pvSendContext );
if( pBufferDesc == NULL ) { return DVERR_OUTOFMEMORY; }
pConnectRequest = (PDVPROTOCOLMSG_CONNECTREQUEST) pBufferDesc->pBufferData;
// Send connection request to the server
pConnectRequest->dwType = DVMSGID_CONNECTREQUEST; pConnectRequest->ucVersionMajor = DVPROTOCOL_VERSION_MAJOR; pConnectRequest->ucVersionMinor = DVPROTOCOL_VERSION_MINOR; pConnectRequest->dwVersionBuild = DVPROTOCOL_VERSION_BUILD; hr = m_lpSessionTransport->SendToServer( pBufferDesc, pvSendContext, DVTRANSPORT_SEND_GUARANTEED );
if( hr != DVERR_PENDING && hr != DV_OK ) { DPFX(DPFPREP, 0, "Error sending connect request hr=0x%x", hr ); } // Pending = OK = expected
else { hr = DV_OK; } return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Send_DisconnectRequest"
HRESULT CDirectVoiceClientEngine::Send_DisconnectRequest(){ PDVPROTOCOLMSG_GENERIC pDisconnectRequest; PDVTRANSPORT_BUFFERDESC pBufferDesc; LPVOID pvSendContext; HRESULT hr;
pBufferDesc = GetTransmitBuffer( sizeof( DVPROTOCOLMSG_GENERIC ), &pvSendContext );
if( pBufferDesc == NULL ) { return DVERR_OUTOFMEMORY; }
pDisconnectRequest = (PDVPROTOCOLMSG_GENERIC) pBufferDesc->pBufferData;
// Send connection request to the server
pDisconnectRequest->dwType = DVMSGID_DISCONNECT; hr = m_lpSessionTransport->SendToServer( pBufferDesc, pvSendContext, DVTRANSPORT_SEND_GUARANTEED );
if( hr != DVERR_PENDING && hr != DV_OK ) { DPFX(DPFPREP, 0, "Error sending connect request hr=0x%x", hr ); } // Pending = OK = expected
else { hr = DV_OK; } return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Send_SettingsConfirm"
HRESULT CDirectVoiceClientEngine::Send_SettingsConfirm(){ PDVPROTOCOLMSG_SETTINGSCONFIRM pSettingsConfirm; PDVTRANSPORT_BUFFERDESC pBufferDesc; LPVOID pvSendContext; HRESULT hr;
pBufferDesc = GetTransmitBuffer( sizeof( DVPROTOCOLMSG_SETTINGSCONFIRM ), &pvSendContext );
if( pBufferDesc == NULL ) { return DVERR_OUTOFMEMORY; }
pSettingsConfirm = (PDVPROTOCOLMSG_SETTINGSCONFIRM) pBufferDesc->pBufferData;
// Send connection request to the server
pSettingsConfirm->dwType = DVMSGID_SETTINGSCONFIRM; pSettingsConfirm->dwHostOrderID = m_dwHostOrderID; pSettingsConfirm->dwFlags = 0;
if( m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX ) { pSettingsConfirm->dwFlags |= DVPLAYERCAPS_HALFDUPLEX; } hr = m_lpSessionTransport->SendToServer( pBufferDesc, pvSendContext, DVTRANSPORT_SEND_GUARANTEED );
if( hr != DVERR_PENDING && hr != DV_OK ) { DPFX(DPFPREP, 0, "Error sending connect request hr=0x%x", hr ); } // Pending = OK = expected
else { hr = DV_OK; } return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Disconnect"
// Disconnect
//
// Implements the IDirectXVoiceClient::Disconnect function
//
// Locks Required:
// - Global Lock
//
// Called By:
// DVC_Disconnect
//
HRESULT CDirectVoiceClientEngine::Disconnect( DWORD dwFlags ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" ); DPFX(DPFPREP, DVF_APIPARAM, "dwFlags = 0x%x", dwFlags );
HRESULT hr;
if( dwFlags & ~(DVFLAGS_SYNC) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid flags specified" ); return DVERR_INVALIDFLAGS; }
CDVCSLock guardLock(&m_csClassLock); guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not initialized" ); return DVERR_NOTINITIALIZED; }
if( m_dwCurrentState == DVCSTATE_CONNECTING ) { m_fDisconnectAsync = !(dwFlags & DVFLAGS_SYNC); DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "DVCE::Disconnect() Abort connection" );
// Handle Connect
SetConnectResult( DVERR_CONNECTABORTED );
SendConnectResult();
SetEvent( m_hConnectAck );
DoSignalDisconnect( DVERR_CONNECTABORTED );
guardLock.Unlock();
if( dwFlags & DVFLAGS_SYNC ) { goto DISCONNECT_WAIT; }
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Returning DVERR_CONNECTABORTING" ); return DVERR_CONNECTABORTING; }
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "State Good.." ); if( m_dwCurrentState == DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Already disconnecting. Waiting on current event" );
guardLock.Unlock();
if( dwFlags & DVFLAGS_SYNC ) { goto DISCONNECT_WAIT; } return DVERR_ALREADYPENDING; } else if( m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Not Connected" ); DPFX(DPFPREP, DVF_APIPARAM, "Returning DVERR_NOTCONNECTED" ); return DVERR_NOTCONNECTED; } else { m_fDisconnectAsync = !(dwFlags & DVFLAGS_SYNC); m_dwSynchBegin = GetTickCount();
// Set current state to disconnecting before we release the lock
SetCurrentState( DVCSTATE_DISCONNECTING );
guardLock.Unlock();
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Disconnect request about to be sent" );
hr = Send_DisconnectRequest();
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Disconnect request transmitted hr=0x%x", hr );
guardLock.Lock();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "DVCE::Disconnect - Error on send 0x%x", hr );
// Inform notify thread to disconnect, since send failed there won't be a confirm
SetEvent( m_hNotifyDisconnect ); hr = DV_OK; } else { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Disconnect sent" ); } }
guardLock.Unlock();
if( dwFlags & DVFLAGS_SYNC ) { goto DISCONNECT_WAIT; }
DPFX(DPFPREP, DVF_INFOLEVEL, "Returning DVERR_PENDING" );
return DVERR_PENDING;
// You should have dropped the Write Loc+k by now
DISCONNECT_WAIT:
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Sync flag, waiting for completion." ); WaitForSingleObject( m_hDisconnectAck, INFINITE ); DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Server response received" );
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Disconnect Result = 0x%x", m_hrDisconnectResult ); return m_hrDisconnectResult;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetSessionDesc"
// GetSessionDesc
//
// Retrieves the current session description.
//
// Called By:
// DVC_GetSessionDesc
//
// Locks Required:
// - Global Read Lock
//
HRESULT CDirectVoiceClientEngine::GetSessionDesc( PDVSESSIONDESC lpSessionDesc ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" );
// 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "lpSessionDescBuffer = 0x%p", lpSessionDesc );
if( lpSessionDesc == NULL || !DNVALID_WRITEPTR(lpSessionDesc,sizeof( DVSESSIONDESC )) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Session desc pointer bad" ); return DVERR_INVALIDPOINTER; }
if( lpSessionDesc->dwSize != sizeof( DVSESSIONDESC ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid size on session desc" ); return DVERR_INVALIDPARAM; }
CDVCSLock guardLock(&m_csClassLock); guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Object not initalized" ); return DVERR_NOTINITIALIZED; }
if( m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not connected" ); return DVERR_NOTCONNECTED; }
memcpy( lpSessionDesc, &m_dvSessionDesc, sizeof( DVSESSIONDESC ) );
DV_DUMP_SD( (LPDVSESSIONDESC) lpSessionDesc );
DPFX(DPFPREP, DVF_APIPARAM, "Returning DV_OK" );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetSoundDeviceConfig"
// GetSoundDeviceConfig
//
// Retrieves the current client configuration.
//
// Called By:
// DVC_GetSoundDeviceConfig
//
// Locks Required:
// - Global Read Lock
HRESULT CDirectVoiceClientEngine::GetSoundDeviceConfig( PDVSOUNDDEVICECONFIG pSoundDeviceConfig, PDWORD pdwBufferSize ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" );
// 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "pSoundDeviceConfig = 0x%p", pSoundDeviceConfig );
DWORD dwRequiredSize = sizeof(DVSOUNDDEVICECONFIG);
if( pdwBufferSize == NULL || !DNVALID_WRITEPTR(pdwBufferSize,sizeof(DWORD)) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer" ); return DVERR_INVALIDPOINTER; }
if( pSoundDeviceConfig != NULL && !DNVALID_WRITEPTR(pSoundDeviceConfig,*pdwBufferSize ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer" ); return DVERR_INVALIDPOINTER; }
if( pSoundDeviceConfig != NULL && pSoundDeviceConfig->dwSize != sizeof( DVSOUNDDEVICECONFIG ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid Size on clientconfig" ); return DVERR_INVALIDPARAM; }
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Object not initialized" ); return DVERR_NOTINITIALIZED; }
if( m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not Connected" ); return DVERR_NOTCONNECTED; }
if( *pdwBufferSize < dwRequiredSize || pSoundDeviceConfig == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Buffer too small!" ); *pdwBufferSize = dwRequiredSize; return DVERR_BUFFERTOOSMALL; } memcpy( pSoundDeviceConfig, &m_dvSoundDeviceConfig, sizeof( DVSOUNDDEVICECONFIG ) );
DV_DUMP_SDC( pSoundDeviceConfig );
// # of bytes written
*pdwBufferSize = dwRequiredSize;
DPFX(DPFPREP, DVF_ENTRYLEVEL, "End" ); DPFX(DPFPREP, DVF_APIPARAM, "Returning DV_OK" );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetClientConfig"
// GetClientConfig
//
// Retrieves the current client configuration.
//
// Called By:
// DVC_GetClientConfig
//
// Locks Required:
// - Global Read Lock
HRESULT CDirectVoiceClientEngine::GetClientConfig( LPDVCLIENTCONFIG lpClientConfig ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" );
// 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "lpClientConfig = 0x%p", lpClientConfig );
if( lpClientConfig == NULL || !DNVALID_WRITEPTR(lpClientConfig,sizeof(DVCLIENTCONFIG) ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer" ); return E_POINTER; }
if( lpClientConfig->dwSize != sizeof( DVCLIENTCONFIG ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid Size on clientconfig" ); return DVERR_INVALIDPARAM; }
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Object not initialized" ); return DVERR_NOTINITIALIZED; }
if( m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not Connected" ); return DVERR_NOTCONNECTED; }
memcpy( lpClientConfig, &m_dvClientConfig, sizeof( DVCLIENTCONFIG ) );
if( lpClientConfig->dwFlags & DVCLIENTCONFIG_AUTOVOICEACTIVATED ) { lpClientConfig->dwThreshold = DVTHRESHOLD_UNUSED; }
DV_DUMP_CC( lpClientConfig );
DPFX(DPFPREP, DVF_ENTRYLEVEL, "End" ); DPFX(DPFPREP, DVF_APIPARAM, "Returning DV_OK" );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetClientConfig"
// SetClientConfig
//
// Sets the current client configuration.
//
// Called By:
// DVC_SetClientConfig
//
// Locks Required:
// - Global Write Lock
//
HRESULT CDirectVoiceClientEngine::SetClientConfig( LPDVCLIENTCONFIG lpClientConfig ){ HRESULT hr;
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Enter" ); // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "lpClientConfig=0x%p", lpClientConfig );
if( lpClientConfig == NULL || !DNVALID_READPTR(lpClientConfig,sizeof(DVCLIENTCONFIG))) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer" ); return E_POINTER; }
DV_DUMP_CC( lpClientConfig );
if( lpClientConfig->dwSize != sizeof( DVCLIENTCONFIG ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "DVCE::SetClientConfig() Error parameters" ); return DVERR_INVALIDPARAM; }
hr = DV_ValidClientConfig( lpClientConfig );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error validating Clientconfig hr=0x%x", hr ); return hr; }
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not initialized" ); return DVERR_NOTINITIALIZED; }
if( m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not connected" ); return DVERR_NOTCONNECTED; }
BOOL bNotifyChange = FALSE, bPlaybackChange = FALSE, bRecordChange = FALSE, bSensitivityChange = FALSE;
// If we're not half duplex, take care of the volume settings
if( !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX ) && !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_NORECVOLAVAILABLE) ) { if( lpClientConfig->lRecordVolume != DVRECORDVOLUME_LAST) { m_dvClientConfig.lRecordVolume = lpClientConfig->lRecordVolume; m_audioRecordBuffer->SetVolume( m_dvClientConfig.lRecordVolume ); } }
if( m_dvClientConfig.lPlaybackVolume != lpClientConfig->lPlaybackVolume ) { m_dvClientConfig.lPlaybackVolume = lpClientConfig->lPlaybackVolume; SetPlaybackVolume( m_dvClientConfig.lPlaybackVolume ); }
if( m_dvClientConfig.dwNotifyPeriod != lpClientConfig->dwNotifyPeriod ) { m_dvClientConfig.dwNotifyPeriod = lpClientConfig->dwNotifyPeriod; SetEvent( m_hNotifyChange ); }
if( !(lpClientConfig->dwFlags & DVCLIENTCONFIG_MANUALVOICEACTIVATED ) ) { m_dvClientConfig.dwThreshold = DVTHRESHOLD_UNUSED; } else if( m_dvClientConfig.dwThreshold != lpClientConfig->dwThreshold ) { if( lpClientConfig->dwThreshold == DVTHRESHOLD_DEFAULT ) { m_dvClientConfig.dwThreshold = s_dwDefaultSensitivity; } else { m_dvClientConfig.dwThreshold = lpClientConfig->dwThreshold; } }
if( (lpClientConfig->dwFlags & DVCLIENTCONFIG_ECHOSUPPRESSION) != (m_dvClientConfig.dwFlags & DVCLIENTCONFIG_ECHOSUPPRESSION) ) { DNEnterCriticalSection( &m_lockPlaybackMode );
m_dwEchoState = DVCECHOSTATE_IDLE;
DNLeaveCriticalSection( &m_lockPlaybackMode ); }
if( m_dvClientConfig.dwBufferAggressiveness == DVBUFFERAGGRESSIVENESS_DEFAULT ) { m_dvClientConfig.dwBufferAggressiveness = s_dwDefaultBufferAggressiveness; }
if( m_dvClientConfig.dwBufferQuality == DVBUFFERQUALITY_DEFAULT ) { m_dvClientConfig.dwBufferQuality = s_dwDefaultBufferQuality; }
// If we haven't specified NOFOCUS and we're not half duplex
if( !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX) && !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_NOFOCUS) ) { // If the settings have changed
if( (m_dvClientConfig.dwFlags & DVCLIENTCONFIG_RECORDMUTE) != (lpClientConfig->dwFlags & DVCLIENTCONFIG_RECORDMUTE) ) { if( lpClientConfig->dwFlags & DVCLIENTCONFIG_RECORDMUTE ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Record Muted: Yielding focus" ); hr = m_audioRecordBuffer->YieldFocus(); } else { DPFX(DPFPREP, DVF_INFOLEVEL, "Record Un-Muted: Attempting to reclaim focus" ); hr = m_audioRecordBuffer->ClaimFocus(); }
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Focus set failed hr=0x%x", hr ); } } }
m_dvClientConfig.dwFlags = lpClientConfig->dwFlags; m_dvClientConfig.dwNotifyPeriod = lpClientConfig->dwNotifyPeriod; guardLock.Unlock();
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Returning DV_OK" );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetCaps"
//
// GetCaps
//
// This function retrieves the caps structure for this DirectPlayVoiceClient
// object.
//
// Called By:
// - DVC_GetCaps
//
// Locks Required:
// - Global Read Lock
//
HRESULT CDirectVoiceClientEngine::GetCaps( LPDVCAPS lpCaps ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::GetCaps() Begin" ); // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "Params: lpCaps: 0x%p", lpCaps );
CDVCSLock guardLock(&m_csClassLock);
if( lpCaps == NULL || !DNVALID_WRITEPTR(lpCaps,sizeof(DVCAPS))) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer" ); return DVERR_INVALIDPOINTER; }
if( lpCaps->dwSize != sizeof( DVCAPS ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error parameters" ); return DVERR_INVALIDPARAM; }
guardLock.Lock();
memcpy( lpCaps, &m_dvCaps, sizeof( DVCAPS ) );
guardLock.Unlock();
DV_DUMP_CAPS( lpCaps );
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Done" );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetCompressionTypes"
//
// GetCompressionTypes
//
// Retrieves configured compression types for this object.
//
// Called By:
// - DVC_GetCompressionTypes
//
// Locks Required:
// - Global Read Lock
//
HRESULT CDirectVoiceClientEngine::GetCompressionTypes( LPVOID lpBuffer, LPDWORD lpdwSize, LPDWORD lpdwNumElements, DWORD dwFlags ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Begin" ); // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "Params: lpBuffer = 0x%p lpdwSize = 0x%p lpdwNumElements = 0x%p, dwFlags = 0x%x", lpBuffer, lpdwSize, lpdwNumElements, dwFlags );
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
HRESULT hres = DVCDB_CopyCompressionArrayToBuffer( lpBuffer, lpdwSize, lpdwNumElements, dwFlags );
guardLock.Unlock();
if( hres == DV_OK ) { DV_DUMP_CI( (LPDVCOMPRESSIONINFO) lpBuffer, *lpdwNumElements ); }
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Done" );
return hres;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CheckForAndRemoveTarget"
//
// CheckForAndRemoveTarget
//
// Checks the current target list for the specified ID and removes it from
// the target list if it is in the target list.
//
HRESULT CDirectVoiceClientEngine::CheckForAndRemoveTarget( DVID dvidID ){ HRESULT hr = DV_OK; DNEnterCriticalSection( &m_csTargetLock );
// Search the list of targets
for( DWORD dwIndex = 0; dwIndex < m_dwNumTargets; dwIndex++ ) { if( m_pdvidTargets[dwIndex] == dvidID ) { if( m_dwNumTargets == 1 ) { hr = InternalSetTransmitTarget( NULL, 0 ); } // We'll re-use the current target array
else { // Collapse the list by either ommiting the last element (if the
// one we want to remove is last, or by moving last element into
// the place in the list we're removing.
if( dwIndex+1 != m_dwNumTargets ) { m_pdvidTargets[dwIndex] = m_pdvidTargets[m_dwNumTargets-1]; } hr = InternalSetTransmitTarget( m_pdvidTargets, m_dwNumTargets-1 ); } break; } }
DNLeaveCriticalSection( &m_csTargetLock );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::InternalSetTransmitTarget"
//
// InternalSetTransmitTarget
//
// Does the work of setting the target. (Assumes values have been validated).
//
// This function is safe to pass a pointer to the current target array. It works
// on a temporary.
//
HRESULT CDirectVoiceClientEngine::InternalSetTransmitTarget( PDVID pdvidTargets, DWORD dwNumTargets ){ DWORD dwRequiredSize; PBYTE pbDataBuffer; PDVMSG_SETTARGETS pdvSetTarget; DNEnterCriticalSection( &m_csTargetLock );
// No targets? set list to NULL
if( dwNumTargets == 0 ) { // Close memory leak
//
// Hawk Bug #
//
if( m_pdvidTargets != NULL ) { delete [] m_pdvidTargets; }
m_pdvidTargets = NULL; } // Otherwise allocate new list and copy
else { PDVID pTmpTargetList; pTmpTargetList = new DVID[dwNumTargets];
if( pTmpTargetList == NULL ) { delete [] m_pdvidTargets; m_dwNumTargets = 0; DPFX(DPFPREP, DVF_ERRORLEVEL, "Memory alloc failure" ); DNLeaveCriticalSection( &m_csTargetLock ); return DVERR_OUTOFMEMORY; }
memcpy( pTmpTargetList, pdvidTargets, dwNumTargets*sizeof(DVID) );
// Kill off old target list
if( m_pdvidTargets != NULL ) delete [] m_pdvidTargets;
m_pdvidTargets = pTmpTargetList; }
m_dwNumTargets = dwNumTargets; m_dwTargetVersion++;
dwRequiredSize = m_dwNumTargets * sizeof( DVID ); dwRequiredSize += sizeof( DVMSG_SETTARGETS );
pbDataBuffer = new BYTE[dwRequiredSize];
if( pbDataBuffer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error allocating memory!" ); DNLeaveCriticalSection( &m_csTargetLock ); return TRUE; }
pdvSetTarget = (PDVMSG_SETTARGETS) pbDataBuffer;
pdvSetTarget->pdvidTargets = (PDVID) (pbDataBuffer+sizeof(DVMSG_SETTARGETS)); pdvSetTarget->dwNumTargets = m_dwNumTargets; pdvSetTarget->dwSize = sizeof( DVMSG_SETTARGETS );
memcpy( pdvSetTarget->pdvidTargets, m_pdvidTargets, sizeof(DVID)*m_dwNumTargets );
NotifyQueue_Add( DVMSGID_SETTARGETS, pdvSetTarget, dwRequiredSize );
delete [] pbDataBuffer;
DNLeaveCriticalSection( &m_csTargetLock );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetTransmitTarget"
//
// SetTransmitTarget
//
// Sets the current transmit target.
//
// Called by:
// - DVC_SetTransmitTarget
//
// Locks Required:
// - Global Write Lock
//
HRESULT CDirectVoiceClientEngine::SetTransmitTarget( PDVID pdvidTargets, DWORD dwNumTargets, DWORD dwFlags ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Begin" ); // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "Params: pdvidTargets = 0x%p dwNumTargets = %d dwFlags = 0x%x", pdvidTargets, dwNumTargets, dwFlags );
if( dwFlags != 0 ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid flags" ); return DVERR_INVALIDFLAGS; }
HRESULT hr;
// Check that the target list is valid
hr = DV_ValidTargetList( pdvidTargets, dwNumTargets );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Target list is not valid" ); return hr; }
DWORD dwIndex;
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Object not initialized" ); return DVERR_NOTINITIALIZED; } if( m_dwCurrentState != DVCSTATE_CONNECTED && m_dwCurrentState != DVCSTATE_CONNECTING ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not connected" ); return DVERR_NOTCONNECTED; } else { if( m_dvSessionDesc.dwFlags & DVSESSION_SERVERCONTROLTARGET ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Denied. Server controlled target" ); return DVERR_NOTALLOWED; }
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_PEER ) { // Loop through target list, confirm they are valid entries
for( dwIndex = 0; dwIndex < dwNumTargets; dwIndex++ ) { if( !m_voiceNameTable.IsEntry(pdvidTargets[dwIndex]) ) {
if( !m_lpSessionTransport->ConfirmValidGroup( pdvidTargets[dwIndex] ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid target" ); return DVERR_INVALIDTARGET; } } } } }
hr = InternalSetTransmitTarget( pdvidTargets, dwNumTargets );
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Done" );
return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetTransmitTarget"
//
// GetTransmitTarget
//
// Retrieves the current transmission target.
//
// Called By:
// - DVC_GetTransmitTarget
//
// Locks Required:
// - Read Lock Required
//
HRESULT CDirectVoiceClientEngine::GetTransmitTarget( LPDVID lpdvidTargets, PDWORD pdwNumElements, DWORD dwFlags ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Begin" ); // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "Params: lpdvidTargets = 0x%p pdwNumElements = 0x%x dwFlags = 0x%x", lpdvidTargets, pdwNumElements, dwFlags );
if( pdwNumElements == NULL || !DNVALID_WRITEPTR( pdwNumElements, sizeof( DWORD ) ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer to num of elements" ); return DVERR_INVALIDPOINTER; }
if( pdwNumElements != NULL && *pdwNumElements > 0 && !DNVALID_WRITEPTR( lpdvidTargets, (*pdwNumElements) * sizeof( DVID) ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid target list buffer specified" ); return DVERR_INVALIDPOINTER; }
if( pdwNumElements == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Must specify a ptr for # of elements" ); return DVERR_INVALIDPARAM; } if( dwFlags != 0 ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid flags" ); return DVERR_INVALIDFLAGS; }
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Object not initialized" ); return DVERR_NOTINITIALIZED; } else if( m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not Connected" ); DPFX(DPFPREP, DVF_APIPARAM, "Returning DVERR_NOTCONNECTED" ); return DVERR_NOTCONNECTED; }
HRESULT hr = DV_OK;
DNEnterCriticalSection( &m_csTargetLock );
if( *pdwNumElements < m_dwNumTargets ) { hr = DVERR_BUFFERTOOSMALL; } else { memcpy( lpdvidTargets, m_pdvidTargets,m_dwNumTargets*sizeof(DVID) ); } *pdwNumElements = m_dwNumTargets;
DNLeaveCriticalSection( &m_csTargetLock );
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Success" );
return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::InitSoundTargetList"
//
// InitSoundTargetList
//
// Initializes the sound target list.
//
// Called By:
// - InitializeSoundSystem
//
// Locks Required:
// - Buffer Lock
//
HRESULT CDirectVoiceClientEngine::InitSoundTargetList(){ DNEnterCriticalSection( &m_csBufferLock );
m_lpstBufferList = NULL;
DNLeaveCriticalSection( &m_csBufferLock ); return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::FreeSoundTargetList"
//
// FreeSoundTargetList
//
// Releases the sound target list.
//
// Also cleans up buffers not released by the user. This must be called before the playback system
// is shutdown.
//
// Called By:
// - DeInitializeSoundSystem
//
// Locks Required:
// - Buffer Lock
//
HRESULT CDirectVoiceClientEngine::FreeSoundTargetList(){ CSoundTarget *lpctFinder, *lpctLast; LONG lRefCount; DVID dvid;
DNEnterCriticalSection( &m_csBufferLock );
lpctLast = NULL; lpctFinder = m_lpstBufferList;
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: DESTROYING OPEN TARGET OBJECTS" );
CHECKLISTINTEGRITY();
// If we enter this loop we're in a questionable state.
//
// The user hasn't called Delete3DSoundBuffer on one or more buffers
//
// We're going to cleanup, if they attempt to access the pointers after this point
// the app will access violate.
//
while( lpctFinder != NULL ) { lpctLast = lpctFinder; lpctFinder = lpctFinder->m_lpstNext;
lRefCount = lpctLast->GetRefCount();
DNASSERT( lRefCount == 2 );
CHECKLISTINTEGRITY();
DPFX(DPFPREP, DVF_ERRORLEVEL, "=========================================================================" ); DPFX(DPFPREP, DVF_ERRORLEVEL, "3D SoundBuffer for ID 0x%x was not released, cleaning it up", lpctLast->GetTarget() ); DPFX(DPFPREP, DVF_ERRORLEVEL, "This is an ERROR. You must Delete3DSoundBuffer before closing the interface." ); DPFX(DPFPREP, DVF_ERRORLEVEL, "DirectPlayVoice has freed the resources, so if you access them you will crash." ); DPFX(DPFPREP, DVF_ERRORLEVEL, "=========================================================================" );
lpctLast->Release();
DeleteSoundTarget( lpctLast->GetTarget() );
CHECKLISTINTEGRITY(); }
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: DESTROYING GENERAL BUFFER" );
if( m_lpstGeneralBuffer != NULL ) { // Release the core's reference to the buffer
lRefCount = m_lpstGeneralBuffer->Release();
// User must not have freed the buffer
if( lRefCount > 0 ) { DNASSERT( lRefCount == 1 );
DPFX(DPFPREP, DVF_ERRORLEVEL, "=========================================================================" ); DPFX(DPFPREP, DVF_ERRORLEVEL, "Main 3D SoundBuffer was not released, cleaning it up" ); DPFX(DPFPREP, DVF_ERRORLEVEL, "This is an ERROR. You must Delete3DSoundBuffer before closing the interface." ); DPFX(DPFPREP, DVF_ERRORLEVEL, "DirectPlayVoice has freed the resources, so if you access them you will crash." ); DPFX(DPFPREP, DVF_ERRORLEVEL, "=========================================================================" );
m_lpstGeneralBuffer->Release(); m_lpstGeneralBuffer = NULL; } else { m_lpstGeneralBuffer = NULL; }
// Releasing the buffer above released this object as well
m_audioPlaybackBuffer = NULL; }
DNLeaveCriticalSection( &m_csBufferLock );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::AddSoundTarget"
//
// AddSoundTarget
//
// Adds a new target to the sound target list
//
// Called By:
// - CreateUserBuffer
//
// Locks Required:
// - Buffer Lock
//
HRESULT CDirectVoiceClientEngine::AddSoundTarget( CSoundTarget *lpcsTarget ){ DNEnterCriticalSection( &m_csBufferLock );
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: [0x%x] ADDSOUNDTARGET", lpcsTarget->GetTarget() );
CHECKLISTINTEGRITY();
lpcsTarget->m_lpstNext = m_lpstBufferList; m_lpstBufferList = lpcsTarget;
CHECKLISTINTEGRITY();
DNLeaveCriticalSection( &m_csBufferLock );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CheckListIntegrity"
void CDirectVoiceClientEngine::CheckListIntegrity(){ CSoundTarget *lpctFinder;
DNEnterCriticalSection( &m_csBufferLock ); lpctFinder = m_lpstBufferList;
while( lpctFinder != NULL ) { if( lpctFinder != NULL ) { DNASSERT( lpctFinder->m_dwSignature == VSIG_SOUNDTARGET ); DNASSERT( lpctFinder->GetRefCount() > 0 ); DNASSERT( lpctFinder->GetRefCount() <= 3 ); DNASSERT( lpctFinder->GetBuffer() != NULL ); }
lpctFinder = lpctFinder->m_lpstNext; }
DNLeaveCriticalSection( &m_csBufferLock );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::DeleteSoundTarget"
//
// DeleteSoundTarget
//
// Removes the specified ID's entry from the sound target list
//
// Called By:
// - DeleteSoundTarget
//
// Locks Required:
// - Buffer lock
//
HRESULT CDirectVoiceClientEngine::DeleteSoundTarget( DVID dvidID ){ CSoundTarget *lpctFinder, *lpctLast, *lpctNext; LONG lRefCount;
DNEnterCriticalSection( &m_csBufferLock ); DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: [0x%x] DELETESOUNDTARGET ", dvidID );
lpctLast = NULL; lpctFinder = m_lpstBufferList;
while( lpctFinder != NULL ) { CHECKLISTINTEGRITY();
if( lpctFinder->GetTarget() == dvidID ) { // Store next pointer
lpctNext = lpctFinder->m_lpstNext; // Release the reference the core has
// If this is the last reference, it destroys the object
//
// If user is holding reference this won't destroy
// the object, the cleanup will.
//
lRefCount = lpctFinder->Release();
// Only remove from list if reference count is 0.
//
// Otherwise you end up with buffer replaying old
// audio
//
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: [0x%x] REMOVING FROM LIST ", dvidID );
/* DNASSERT( lRefCount == 0 );
if( lRefCount == 0 ) { */ if( lpctLast == NULL ) { m_lpstBufferList = lpctNext; } else { lpctLast->m_lpstNext = lpctNext; }// }
CHECKLISTINTEGRITY();
DNLeaveCriticalSection( &m_csBufferLock ); return DV_OK; }
lpctLast = lpctFinder; lpctFinder = lpctFinder->m_lpstNext; }
DNLeaveCriticalSection( &m_csBufferLock );
return DVERR_INVALIDPLAYER;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::FindSoundTarget"
//
// FindSoundTarget
//
// Look for sound target buffer for the specified user.
//
// If it exists, return it in lpcsTarget
//
// Called By:
// - CreateUserBuffer
//
// Locks Required:
// - Buffer Lock
//
HRESULT CDirectVoiceClientEngine::FindSoundTarget( DVID dvidID, CSoundTarget **lpcsTarget ){ DNEnterCriticalSection( &m_csBufferLock );
CHECKLISTINTEGRITY(); *lpcsTarget = NULL;
CSoundTarget *lpctFinder;
lpctFinder = m_lpstBufferList;
while( lpctFinder != NULL ) { if( lpctFinder->GetTarget() == dvidID ) { *lpcsTarget = lpctFinder; lpctFinder->AddRef(); DNLeaveCriticalSection( &m_csBufferLock ); return DV_OK; }
lpctFinder = lpctFinder->m_lpstNext; }
CHECKLISTINTEGRITY();
DNLeaveCriticalSection( &m_csBufferLock );
return DVERR_INVALIDPLAYER;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetupPlaybackBufferDesc"
void CDirectVoiceClientEngine::SetupPlaybackBufferDesc( LPDSBUFFERDESC lpdsBufferDesc, LPDSBUFFERDESC lpdsBufferSource ){ DV_SetupBufferDesc( lpdsBufferDesc, lpdsBufferSource, s_lpwfxPlaybackFormat, m_dwUnCompressedFrameSize*m_dwNumPerBuffer );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Create3DSoundBuffer"
//
// Create3DSoundBuffer
//
// Creates a mixing buffer (a sound target) for the specified user ID.
//
// Called By:
// - DVC_CreateUserBuffer
//
// Locks Required:
// - Global Read Lock
//
HRESULT CDirectVoiceClientEngine::Create3DSoundBuffer( DVID dvidID, LPDIRECTSOUNDBUFFER lpdsBuffer, DWORD dwPriority, DWORD dwFlags, LPDIRECTSOUND3DBUFFER *lpBuffer ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Begin" ); // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "Params: dvidID = 0x%x lpdsBuffer = 0x%p dwPriority = 0x%x dwFlags = 0x%x lpBuffer = 0x%p", dvidID, lpdsBuffer, dwPriority, dwFlags, lpBuffer );
HRESULT hr; if( lpBuffer == NULL || !DNVALID_WRITEPTR( lpBuffer, sizeof( LPDIRECTSOUND3DBUFFER ) ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer" ); return DVERR_INVALIDPOINTER; }
if( dvidID == DVID_REMAINING ) { if( lpdsBuffer != NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Cannot specify a buffer for the DVID_REMAINING buffer" ); DPFX(DPFPREP, DVF_ERRORLEVEL, "You can set these values from the SoundDeviceConfig structure" ); return DVERR_INVALIDPARAM; }
if( dwFlags != 0 || dwPriority != 0 ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Cannot specify non-zero flags for voice management for DVID_REMAINING buffer" ); DPFX(DPFPREP, DVF_ERRORLEVEL, "You can set these values from the SoundDeviceConfig structure" ); return DVERR_INVALIDFLAGS; } } else { hr = DV_ValidBufferSettings( lpdsBuffer, dwPriority, dwFlags, s_lpwfxPlaybackFormat );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid settings for buffer description hr=0x%x", hr ); return hr; }
dwFlags |= DSBPLAY_LOOPING; }
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not initialized" ); return DVERR_NOTINITIALIZED; } else if( m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not connected" ); return DVERR_NOTCONNECTED; }
if( this->m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_MIXING && dvidID != DVID_REMAINING ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Only DVID_REMAINING can be spatialized in mixing sessions" ); return DVERR_NOTALLOWED; }
if( dvidID == m_dvidLocal ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Cannot create buffer for local player!" ); return DVERR_INVALIDPLAYER; }
if( dvidID != DVID_ALLPLAYERS && dvidID != DVID_REMAINING && !m_voiceNameTable.IsEntry(dvidID) ) { guardLock.Unlock(); if( !m_lpSessionTransport->ConfirmValidGroup( dvidID ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid player/group ID" ); return DVERR_INVALIDPLAYER; }
guardLock.Lock(); }
DWORD dwMode;
// Handle request for 3d buffer on the main buffer
if( dvidID == DVID_REMAINING ) { LPDIRECTSOUND3DBUFFER lpds3dTmp;
lpds3dTmp = m_lpstGeneralBuffer->Get3DBuffer();
if( lpds3dTmp == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "No 3d support" ); return DVERR_NO3DSOUND; }
hr = lpds3dTmp->GetMode( &dwMode );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to get 3d buffer mode hr=0x%x", hr ); return DVERR_GENERIC; }
if( dwMode != DS3DMODE_DISABLE ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Already have a buffer for specified user" ); return DVERR_ALREADYBUFFERED; }
// Check return code
hr = lpds3dTmp->SetMode( DS3DMODE_NORMAL, DS3D_IMMEDIATE );
if( hr != DV_OK ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to set the mode to activate 3d buffer hr=0x%x", hr ); return hr; }
// Add a reference for the user (core already has one)
m_lpstGeneralBuffer->AddRef();
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Done" );
*lpBuffer = lpds3dTmp;
return DV_OK; }
LONG lResult; CSoundTarget *lpstTarget = NULL;
// Check for existing buffer.. if it already exists return it
// (Note: Adds a reference to the buffer)
hr = FindSoundTarget( dvidID, &lpstTarget );
if( hr == DV_OK ) { if( lpstTarget != NULL ) { lResult = lpstTarget->Release();
DNASSERT( lResult != 0 ); } DPFX(DPFPREP, DVF_ERRORLEVEL, "CreateUserBuffer: Find of buffer failed. hr=0x%x", hr ); return DVERR_ALREADYBUFFERED; }
if( lpstTarget != NULL ) { lResult = lpstTarget->Release();
DNASSERT( lResult != 0 );
DPFX(DPFPREP, DVF_ERRORLEVEL, "CreateUserBuffer: Buffer already available" ); return DVERR_ALREADYBUFFERED; }
// If the user has given us a buffer
if( lpdsBuffer ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Creating buffer using user buffer" );
lpstTarget = new CSoundTarget( dvidID, m_audioPlaybackDevice, lpdsBuffer, (s_lpwfxPlaybackFormat->wBitsPerSample == 8), dwPriority, dwFlags, m_dwUnCompressedFrameSize ); } else { DSBUFFERDESC dsBufferDesc;
DPFX(DPFPREP, DVF_INFOLEVEL, "Creating buffer using user buffer" );
// Fill in appropriate values for the buffer description
SetupPlaybackBufferDesc( &dsBufferDesc, NULL );
// Buffer and sound target ref count = 1
lpstTarget = new CSoundTarget( dvidID, m_audioPlaybackDevice, &dsBufferDesc, dwPriority, dwFlags, m_dwUnCompressedFrameSize ); }
if( lpstTarget == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "CreateUserBuffer: Failed allocating sound target" ); return DVERR_OUTOFMEMORY; }
hr = lpstTarget->GetInitResult();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "CreateUserBuffer: Init of buffer failed. hr=0x%x", hr ); lpstTarget->Release(); return hr; }
hr = lpstTarget->StartMix();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to start the mix on secondary buffer hr=0x%x.", hr ); lpstTarget->Release(); return hr; }
// Buffer and sound target ref count = 2
lpstTarget->AddRef();
hr = AddSoundTarget( lpstTarget );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "CreateUserBuffer: AddTarget failed. hr=0x%x", hr ); // Destroy reference from above
lResult = lpstTarget->Release();
DNASSERT( lResult != 0 );
// Destroy base reference
lResult = lpstTarget->Release();
DNASSERT( lResult == 0 ); return hr; }
*lpBuffer = lpstTarget->Get3DBuffer();
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Done" );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Delete3DSoundBuffer"
//
// Delete3DSoundBuffer
//
// Removes the specified ID from the mixer buffer list. Further speech from
// the specified player will be played in the remaining buffer.
//
// Called By:
// - DVC_DeleteUserBuffer
//
// Locks Required:
// - Global Write Lock
//
HRESULT CDirectVoiceClientEngine::Delete3DSoundBuffer( DVID dvidID, LPDIRECTSOUND3DBUFFER *lplpBuffer ){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "Begin" ); // 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_APIPARAM, "Params: dvidID = 0x%x lpBuffer = 0x%p", dvidID, lplpBuffer ); if( lplpBuffer == NULL || !DNVALID_WRITEPTR( lplpBuffer, sizeof( LPDIRECTSOUND3DBUFFER ) ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid pointer" ); return E_POINTER; } CDVCSLock guardLock(&m_csClassLock); guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not initialized" ); return DVERR_NOTINITIALIZED; } else if( m_dwCurrentState != DVCSTATE_CONNECTED && m_dwCurrentState != DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not connected" ); return DVERR_NOTCONNECTED; }
HRESULT hr; DWORD dwMode; LONG lResult;
// Handle request to disable 3D on the main buffer
if( dvidID == DVID_REMAINING ) { LPDIRECTSOUND3DBUFFER lpTmpBuffer; lpTmpBuffer = m_lpstGeneralBuffer->Get3DBuffer();
if( lpTmpBuffer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "No 3d buffer supported" ); return DVERR_NOTBUFFERED; }
if( lpTmpBuffer != *lplpBuffer ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Buffer passed in does not belong to specified id" ); return DVERR_INVALIDPARAM; }
hr = lpTmpBuffer->GetMode( &dwMode );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to get current mode hr=0x%x", hr ); return DVERR_GENERIC; }
if( dwMode == DS3DMODE_DISABLE ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Not buffered" ); return DVERR_NOTBUFFERED; }
// Check return code
// Add reference
hr = lpTmpBuffer->SetMode( DS3DMODE_DISABLE, DS3D_IMMEDIATE );
if( hr != DV_OK ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to set the mode to activate 3d buffer hr=0x%x", hr ); return DVERR_GENERIC; }
hr = lpTmpBuffer->SetPosition( 0.0, 0.0, 0.0, DS3D_IMMEDIATE );
// Not a Failure condition.
if( hr != DV_OK ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to set the position of the 3d buffer hr=0x%x", hr ); }
// Remove reference the user has
lResult = m_lpstGeneralBuffer->Release();
*lplpBuffer = NULL;
return DV_OK; }
CSoundTarget *lpstTarget;
hr = FindSoundTarget( dvidID, &lpstTarget );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "CreateUserBuffer: Find of buffer failed. hr=0x%x", hr ); return DVERR_NOTBUFFERED; }
if( lpstTarget == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "DeleteUserBuffer: Unable to retrieve user record" ); return DVERR_NOTBUFFERED; }
if( lpstTarget->Get3DBuffer() != *lplpBuffer ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Buffer passed in does not belong to specified id" ); // Get rid of the reference this func has
lResult = lpstTarget->Release();
DNASSERT( lResult != 0 ); return DVERR_INVALIDPARAM; }
DPFX(DPFPREP, DVF_SOUNDTARGET_DEBUG_LEVEL, "SOUNDTARGET: [0x%x] DESTROY3DBUFFER ", dvidID );
// Get rid of the reference the FindSoundTarget has
lResult = lpstTarget->Release();
DNASSERT( lResult != 0 );
// Get rid of the reference the user has
lResult = lpstTarget->Release();
DNASSERT( lResult != 0 );
// Destroy the last reference (unless there is one outstanding)
DeleteSoundTarget( dvidID );
*lplpBuffer = NULL;
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Done" );
return DV_OK; }
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
// DIRECTPLAY/NET --> DirectXVoiceClient Interface
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ReceiveSpeechMessage"
// ReceiveSpeechMessage
//
// Called by DirectPlay/DirectNet when a DirectXVoice message is received
//
// Called By:
// - DV_ReceiveSpeechMessage
//
// Locks Required:
// - None
//
BOOL CDirectVoiceClientEngine::ReceiveSpeechMessage( DVID dvidSource, LPVOID lpMessage, DWORD dwSize ){ BOOL fResult;
PDVPROTOCOLMSG_FULLMESSAGE lpdvFullMessage;
// if we dont' have at least one byte then we are going to bail
if ( dwSize < 1 ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::ReceiveSpeechMessage() Ignoring zero-byte sized message from=0x%x", dvidSource ); return FALSE; }
lpdvFullMessage = (PDVPROTOCOLMSG_FULLMESSAGE) lpMessage;
if( !ValidatePacketType( lpdvFullMessage ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::ReceiveSpeechMessage() Ignoring message with invalid packet type, type=0x%x, from=0x%x", lpdvFullMessage->dvGeneric.dwType, dvidSource ); return FALSE; } switch( lpdvFullMessage->dvGeneric.dwType ) { case DVMSGID_HOSTMIGRATELEAVE: fResult = HandleHostMigrateLeave( dvidSource, static_cast<PDVPROTOCOLMSG_HOSTMIGRATELEAVE>(lpMessage), dwSize ); break; case DVMSGID_HOSTMIGRATED: fResult = HandleHostMigrated( dvidSource, static_cast<PDVPROTOCOLMSG_HOSTMIGRATED>(lpMessage),dwSize ); break; case DVMSGID_CONNECTREFUSE: fResult = HandleConnectRefuse( dvidSource, static_cast<PDVPROTOCOLMSG_CONNECTREFUSE>(lpMessage), dwSize ); break; case DVMSGID_CONNECTACCEPT: fResult = HandleConnectAccept( dvidSource, static_cast<PDVPROTOCOLMSG_CONNECTACCEPT>(lpMessage), dwSize ); break; case DVMSGID_CREATEVOICEPLAYER: fResult = HandleCreateVoicePlayer( dvidSource, static_cast<PDVPROTOCOLMSG_PLAYERJOIN>(lpMessage), dwSize ); break; case DVMSGID_DELETEVOICEPLAYER: fResult = HandleDeleteVoicePlayer( dvidSource, static_cast<PDVPROTOCOLMSG_PLAYERQUIT>(lpMessage), dwSize ); break; case DVMSGID_SPEECH: fResult = HandleSpeech( dvidSource, static_cast<PDVPROTOCOLMSG_SPEECHHEADER>(lpMessage), dwSize ); break; case DVMSGID_SPEECHBOUNCE: fResult = HandleSpeechBounce( dvidSource, static_cast<PDVPROTOCOLMSG_SPEECHHEADER>(lpMessage), dwSize ); break; case DVMSGID_SPEECHWITHFROM: fResult = HandleSpeechWithFrom( dvidSource, static_cast<PDVPROTOCOLMSG_SPEECHWITHFROM>(lpMessage), dwSize ); break; case DVMSGID_DISCONNECTCONFIRM: fResult = HandleDisconnectConfirm( dvidSource, static_cast<PDVPROTOCOLMSG_DISCONNECT>(lpMessage), dwSize); break; case DVMSGID_SETTARGETS: fResult = HandleSetTarget( dvidSource, static_cast<PDVPROTOCOLMSG_SETTARGET>(lpMessage), dwSize ); break; case DVMSGID_SESSIONLOST: fResult = HandleSessionLost( dvidSource, static_cast<PDVPROTOCOLMSG_SESSIONLOST>(lpMessage), dwSize ); break; case DVMSGID_PLAYERLIST: fResult = HandlePlayerList( dvidSource, static_cast<PDVPROTOCOLMSG_PLAYERLIST>(lpMessage), dwSize ); break; default: DPFX(DPFPREP, DVF_WARNINGLEVEL, "DVCE::ReceiveSpeechMessage() Ignoring non-speech message id=0x%x from=0x%x", lpdvFullMessage->dvGeneric.dwType, dvidSource ); return FALSE; }
return fResult;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleSetTarget"
// HandleSetTarget
//
// Handles server settarget messages. Sets the local target.
//
BOOL CDirectVoiceClientEngine::HandleSetTarget( DVID dvidSource, PDVPROTOCOLMSG_SETTARGET lpdvSetTarget, DWORD dwSize ){ HRESULT hr;
// Confirm that server controlled targetting is enabled. If it isn't then this should be ignored.
if( !(m_dvSessionDesc.dwFlags & DVSESSION_SERVERCONTROLTARGET) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSetTarget() Ignoring target message in session w/o server controlled targetting from=0x%x", dvidSource ); return FALSE; }
// Ignore set target message unless it is from the server.
if( dvidSource != m_dvidServer ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSetTarget() Ignoring set target from non-server from=0x%x", dvidSource ); return FALSE; }
// check structure size first so that we don't crash by accessing bad data
if ( dwSize < sizeof( DVPROTOCOLMSG_SETTARGET ) || ( dwSize != (sizeof( DVPROTOCOLMSG_SETTARGET ) + ( lpdvSetTarget->dwNumTargets * sizeof(DVID) ) ) ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSetTarget() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
if( lpdvSetTarget->dwNumTargets > DV_MAX_TARGETS ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSetTarget() Ignoring message with too many targets, targets=0x%x, from=0x%x", lpdvSetTarget->dwNumTargets, dvidSource ); return FALSE; } hr = InternalSetTransmitTarget( (DWORD *) &lpdvSetTarget[1], lpdvSetTarget->dwNumTargets );
DNASSERT( hr == DV_OK );
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleHostMigrateLeave"
BOOL CDirectVoiceClientEngine::HandleHostMigrateLeave( DVID dvidSource, PDVPROTOCOLMSG_HOSTMIGRATELEAVE lpdvHostMigrateLeave, DWORD dwSize ){ // Call RemovePlayer with the ID of the person who sent this,
// which should be the host.
DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Triggered by DVMSGID_HOSTMIGRATELEAVE" ); MigrateHost_RunElection();
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleHostMigrated"
BOOL CDirectVoiceClientEngine::HandleHostMigrated( DVID dvidSource, PDVPROTOCOLMSG_HOSTMIGRATED lpdvHostMigrated, DWORD dwSize ){ HRESULT hr;
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
// We're not yet connected, so we can't send our settings to the server yet.
// However, because of the write lock we know that when the connection
// completes we'll have the right host. (Transparently to the client).
//
// We need to proceed if we're disconnecting because we need to send a new disconnect confirm
//
if( m_dwCurrentState != DVCSTATE_CONNECTED && m_dwCurrentState != DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Could not respond to new host yet, not yet initialized" ); return TRUE; }
if( dvidSource != m_dvidServer ) { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Ignoring host migration from 0x%x -- 0x%x is server", dvidSource, m_dvidServer ); return TRUE; }
guardLock.Unlock();
if( m_dwCurrentState == DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Sending NEW host disconnect request" );
hr = Send_DisconnectRequest();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Internal send failed hr=0x%x", hr ); } else { hr=DV_OK; } } else { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Player 0x%x received host migrated message!", m_dvidLocal ); DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Sending player confirm message" ); DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: According to message Player 0x%x is new host", dvidSource );
hr = Send_SettingsConfirm();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Internal send failed hr=0x%x", hr ); } else { hr=DV_OK; } }
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleConnectRefuse"
// HandleConnectRefuse
//
// Handles connection refusals
//
BOOL CDirectVoiceClientEngine::HandleConnectRefuse( DVID dvidSource, PDVPROTOCOLMSG_CONNECTREFUSE lpdvConnectRefuse, DWORD dwSize ){ if ( dwSize != sizeof( DVPROTOCOLMSG_CONNECTREFUSE ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleConnectRefuse() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
// This prevents someone from sending a connect refuse to bump off a valid player
if( GetCurrentState() != DVCSTATE_CONNECTING ) {
DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleConnectRefuse() Ignoring connect refuse AFTER connection from=0x%x", dvidSource ); return FALSE; }
// Prevent processing of this message unless it came from the server
if( dvidSource != m_dvidServer ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleConnectRefuse() Ignoring connect refuse from non-server - from=0x%x", dvidSource ); return FALSE; }
// Do some brain dead error checking. Should never happen but print
// some debug spew just in case
if (SUCCEEDED(lpdvConnectRefuse->hresResult)) { DPFX(DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "CDirectVoiceClientEngine::HandleConnectRefuse but reason given is success!" ); } SetConnectResult( lpdvConnectRefuse->hresResult ); SetEvent( m_hNotifyConnect );
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::DeInitializeClientServer"
// DeInitializeClientServer
//
// This function is responsible for pre-allocating the information
// for receiving client/server voice.
//
void CDirectVoiceClientEngine::DeInitializeClientServer(){ DVPROTOCOLMSG_PLAYERQUIT dvPlayerQuit;
dvPlayerQuit.dwType = DVMSGID_DELETEVOICEPLAYER; dvPlayerQuit.dvidID = m_dvidServer;
HandleDeleteVoicePlayer( 0, &dvPlayerQuit, sizeof( DVPROTOCOLMSG_PLAYERQUIT ) ); }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::InitializeClientServer"
// InitializeClientServer
//
// This function is responsible for pre-allocating the information
// for receiving client/server voice
//
HRESULT CDirectVoiceClientEngine::InitializeClientServer(){ DPFX(DPFPREP, DVF_INFOLEVEL, "DVCE::InitializeClientServer() - Initializing Client/Server Queues" );
HRESULT hr;
CVoicePlayer *pNewPlayer; QUEUE_PARAMS queueParams;
pNewPlayer = (CVoicePlayer*)m_fpPlayers.Get();
if( pNewPlayer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to allocate new player for client/server" ); return DVERR_OUTOFMEMORY; }
ASSERT_VPLAYER(pNewPlayer);
hr = pNewPlayer->Initialize( m_dvidServer, 0, 0, NULL, &m_fpPlayers );
if( FAILED( hr ) ) { pNewPlayer->Release(); DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to initialize server player record" ); return hr; }
queueParams.wFrameSize = m_dwCompressedFrameSize; queueParams.bInnerQueueSize = m_lpdvfCompressionInfo->wInnerQueueSize; queueParams.bMaxHighWaterMark = m_lpdvfCompressionInfo->wMaxHighWaterMark, queueParams.iQuality = m_dvClientConfig.dwBufferQuality; queueParams.iHops = 2; queueParams.iAggr = m_dvClientConfig.dwBufferAggressiveness; queueParams.bInitHighWaterMark = 2; queueParams.wQueueId = -1; queueParams.wMSPerFrame = m_lpdvfCompressionInfo->dwTimeout, queueParams.pFramePool = m_pFramePool;
hr = pNewPlayer->CreateQueue( &queueParams );
if( FAILED( hr ) ) { pNewPlayer->Release(); DPFX(DPFPREP, DVF_ERRORLEVEL, "Could not create queue hr=0x%x", hr ); return hr; }
hr = m_voiceNameTable.AddEntry( m_dvidServer, pNewPlayer );
if( FAILED( hr ) ) { // Main ref
pNewPlayer->Release();
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to add entry to nametable hr=0x%x", hr ); return TRUE; }
// Add a reference for the player to the "Playback Add List"
DNEnterCriticalSection( &m_csPlayAddList ); pNewPlayer->AddRef(); pNewPlayer->AddToPlayList( &m_blPlayAddPlayers ); DNLeaveCriticalSection( &m_csPlayAddList );
// Add a reference for the player to the "Notify Add List"
DNEnterCriticalSection( &m_csNotifyAddList ); pNewPlayer->AddRef(); pNewPlayer->AddToNotifyList( &m_blNotifyAddPlayers ); DNLeaveCriticalSection( &m_csNotifyAddList );
pNewPlayer->SetAvailable( TRUE ); m_fLocalPlayerAvailable = TRUE;
// Release our personal reference
pNewPlayer->Release();
DPFX(DPFPREP, DVF_INFOLEVEL, "DVCE::InitializeClientServer() - Done Initializing Client/Server Queues" );
return DP_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::DoConnectResponse"
void CDirectVoiceClientEngine::DoConnectResponse(){ HRESULT hr = DV_OK;
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
if( m_dwCurrentState != DVCSTATE_CONNECTING ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Aborting Connection & server response arrived" ); return; }
// Work from the default assumption that something will screw up
SetConnectResult( DVERR_GENERIC );
ClientStats_Begin();
#ifndef __DISABLE_SOUND
// Handle sound initialization
hr = InitializeSoundSystem();
if( FAILED(hr) ) { SetConnectResult(hr); DPFX(DPFPREP, DVF_ERRORLEVEL, "Sound Initialization Failed hr=0x%x", hr ); goto EXIT_ERROR; }
#endif
hr = SetupSpeechBuffer();
if( FAILED( hr ) ) { SetConnectResult(hr); DPFX(DPFPREP, DVF_ERRORLEVEL, "Could not init speech buffers hr=0x%x", hr ); goto EXIT_ERROR; }
DPFX(DPFPREP, DVF_INFOLEVEL, "DVCE::HandleConnectAccept() - Sound Initialized" );
// If we're running in client/server we need to pre-create a single buffer
// and compressor
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_MIXING || m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_ECHO ) { hr = InitializeClientServer();
if( FAILED( hr ) ) { SetConnectResult(hr); DPFX(DPFPREP, DVF_ERRORLEVEL, "Could not init client/server hr=0x%x", hr ); goto EXIT_ERROR; } }
// We need to make player available in client/server because there will be no indication
if( m_dvSessionDesc.dwSessionType != DVSESSIONTYPE_PEER ) { m_fLocalPlayerAvailable = TRUE; }
#ifndef __DISABLE_SOUND
// Start playback thread
// Create Thread events
m_hPlaybackTerminate = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hPlaybackDone = CreateEvent( NULL, FALSE, FALSE, NULL );
// Create Semaphores for playback and record
m_thTimerInfo.hPlaybackTimerEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); m_thTimerInfo.lPlaybackCount = 0; m_thTimerInfo.hRecordTimerEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
if( m_hPlaybackTerminate == NULL || m_hPlaybackDone == NULL || m_thTimerInfo.hPlaybackTimerEvent == NULL || m_thTimerInfo.hRecordTimerEvent == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Windows error, event create failure." ); SetConnectResult( DVERR_GENERIC ); goto EXIT_ERROR; }
// Create Multimedia timer
m_pTimer = new DvTimer;
if( m_pTimer == NULL ) { SetConnectResult( DVERR_OUTOFMEMORY );
goto EXIT_ERROR; }
if( !m_pTimer->Create( m_lpdvfCompressionInfo->dwTimeout / DV_CLIENT_WAKEUP_MULTIPLER, &m_thTimerInfo, MixingWakeupProc ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create timer." ); SetConnectResult( DVERR_GENERIC ); goto EXIT_ERROR; }
m_hPlaybackThreadHandle = (HANDLE) _beginthread( PlaybackThread, 0, this ); #ifdef __CORE_THREAD_PRIORITY_HIGH
SetThreadPriority( m_hPlaybackThreadHandle, THREAD_PRIORITY_TIME_CRITICAL );#endif
// 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_INFOLEVEL, "DVCE::HandleConnectAccept() - Playback Thread Started: 0x%p", m_hPlaybackThreadHandle );
if( !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX) ) { m_hRecordTerminate = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hRecordDone = CreateEvent( NULL, FALSE, FALSE, NULL ); if (m_hRecordTerminate==NULL || m_hRecordDone==NULL) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Windows error, event create failure. hr=0x%x", GetLastError() ); SetConnectResult( DVERR_GENERIC ); goto EXIT_ERROR; } // Start Record Thread
m_hRecordThreadHandle = (HANDLE) _beginthread( RecordThread, 0, this );#ifdef __CORE_THREAD_PRIORITY_HIGH
SetThreadPriority( m_hRecordThreadHandle, THREAD_PRIORITY_TIME_CRITICAL );#endif
// 7/31/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers, addresses, and handles.
DPFX(DPFPREP, DVF_INFOLEVEL, "DVCE::HandleConnectAccept() - Record Thread Started: 0x%p", m_hRecordThreadHandle ); } else { m_hRecordTerminate = NULL; m_hRecordDone = NULL; } #endif
SetCurrentState( DVCSTATE_CONNECTED ); SetConnectResult(DV_OK);
DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::HandleConnectAccept() Success" );
SendConnectResult();
///////
guardLock.Unlock();
hr = Send_SettingsConfirm();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to send connect confirmation hr=0x%x", hr ); DPFX(DPFPREP, DVF_ERRORLEVEL, "Other threads will cleanup because connection must be gone" ); }
SetEvent( m_hConnectAck );
return;
EXIT_ERROR:
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_MIXING || m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_ECHO ) { DeInitializeClientServer(); }
DPFX(DPFPREP, DVF_ERRORLEVEL, "HandleConnectAccept Failed hr=0x%x", GetConnectResult() ); DV_DUMP_GUID( m_dvSessionDesc.guidCT );
guardLock.Unlock();
Cleanup();
SendConnectResult(); SetEvent( m_hConnectAck ); return;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleConnectAccept"
// HandleConnectAccepts
//
// Handles connect accepts. Sets connected flag, finishes initialization, informs the
// connect function to proceed (if it's waiting).
//
BOOL CDirectVoiceClientEngine::HandleConnectAccept( DVID dvidSource, PDVPROTOCOLMSG_CONNECTACCEPT lpdvConnectAccept, DWORD dwSize ){ char tmpString[100];
if ( dwSize != sizeof( DVPROTOCOLMSG_CONNECTACCEPT ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleConnectAccept() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
if( !ValidateSessionType( lpdvConnectAccept->dwSessionType ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleConnectAccept() Ignoring message with invalid session type, type=0x%x, from=0x%x", lpdvConnectAccept->dwSessionType, dvidSource ); return FALSE; }
if( !ValidateSessionFlags( lpdvConnectAccept->dwSessionFlags ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleConnectAccept() Ignoring message with invalid session flags, flags=0x%x, from=0x%x", lpdvConnectAccept->dwSessionFlags, dvidSource ); return FALSE; } DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::HandleConnectAccept() Entry" );
CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
// We're already connected, server is responding to the earlier request
if( m_dwCurrentState != DVCSTATE_CONNECTING ) { return TRUE; }
m_hPlaybackTerminate = NULL; m_hPlaybackDone = NULL; m_thTimerInfo.hPlaybackTimerEvent = NULL; m_thTimerInfo.hRecordTimerEvent = NULL; m_pTimer = NULL;
// Inform transport layer who the server is. (So it no longer thinks it's DPID_ALL).
m_lpSessionTransport->MigrateHost( dvidSource ); m_dvidServer = m_lpSessionTransport->GetServerID(); DVPROTOCOLMSG_FULLMESSAGE dvMessage;
DPFX(DPFPREP, DVF_INFOLEVEL, "Connect Accept Received" );
m_dvSessionDesc.dwSize = sizeof( DVSESSIONDESC ); m_dvSessionDesc.dwBufferAggressiveness = 0; m_dvSessionDesc.dwBufferQuality = 0; m_dvSessionDesc.dwFlags = lpdvConnectAccept->dwSessionFlags; m_dvSessionDesc.guidCT = lpdvConnectAccept->guidCT; m_dvSessionDesc.dwSessionType = lpdvConnectAccept->dwSessionType;
HRESULT hr = DVCDB_GetCompressionInfo( m_dvSessionDesc.guidCT, &m_lpdvfCompressionInfo );
if( FAILED( hr ) ) { SetConnectResult( DVERR_COMPRESSIONNOTSUPPORTED ); DPFX(DPFPREP, DVF_ERRORLEVEL, "Invalid Compression Type" ); SetEvent( m_hNotifyConnect ); return TRUE; }
SetConnectResult( DV_OK );
DV_DUMP_CIF( m_lpdvfCompressionInfo, 1 ); SetEvent( m_hNotifyConnect );
return TRUE;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandlePlayerList"
BOOL CDirectVoiceClientEngine::HandlePlayerList( DVID dvidSource, PDVPROTOCOLMSG_PLAYERLIST lpdvPlayerList, DWORD dwSize ){ DVPROTOCOLMSG_PLAYERJOIN dvMsgPlayerJoin; // Used to fake out HandleCreateVoicePlayer
DWORD dwIndex;
// Prevent player list path in non-peer-to-peer sessions
if( m_dvSessionDesc.dwSessionType != DVSESSIONTYPE_PEER ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "Ignoring playerlist in non-peer session from=0x%x", dvidSource ); return FALSE; }
// Prevent player list from non-server.
if( dvidSource != m_dvidServer ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "Ignoring player list from non-host - from=0x%x", dvidSource ); return FALSE; }
// check structure size first so that we don't crash by accessing bad data
if ( dwSize < sizeof( DVPROTOCOLMSG_PLAYERLIST ) || ( dwSize != (sizeof( DVPROTOCOLMSG_PLAYERLIST ) + ( lpdvPlayerList->dwNumEntries * sizeof(DVPROTOCOLMSG_PLAYERLIST_ENTRY ) ) ) ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandlePlayerList() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
// Should transition this from -1 to 0 if this is the first time, otherwise it will be positive
if( InterlockedIncrement( &m_iPlayerListReceived ) != 0 ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "Ignoring dup player list - from=0x%x", dvidSource ); return FALSE; } const DVPROTOCOLMSG_PLAYERLIST_ENTRY *pdvPlayerList = (DVPROTOCOLMSG_PLAYERLIST_ENTRY *) &lpdvPlayerList[1];
// Get our host order ID
m_dwHostOrderID = lpdvPlayerList->dwHostOrderID;
DPFX(DPFPREP, DVF_INFOLEVEL, "Received player list. Unpacking %d entries", lpdvPlayerList->dwNumEntries );
for( dwIndex = 0; dwIndex < lpdvPlayerList->dwNumEntries; dwIndex++ ) { dvMsgPlayerJoin.dwType = DVMSGID_CREATEVOICEPLAYER; dvMsgPlayerJoin.dvidID = pdvPlayerList[dwIndex].dvidID; dvMsgPlayerJoin.dwFlags = pdvPlayerList[dwIndex].dwPlayerFlags; dvMsgPlayerJoin.dwHostOrderID = pdvPlayerList[dwIndex].dwHostOrderID;
if( !InternalCreateVoicePlayer( dvidSource, &dvMsgPlayerJoin, sizeof( DVPROTOCOLMSG_PLAYERJOIN ) ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Handle voice player failed during unpack" ); return FALSE; } }
return TRUE; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyComplete_SyncWait"
//
// NotifyComplete_SyncWait
//
// This is a completion function for notifications which need to be performed synchronously.
//
void CDirectVoiceClientEngine::NotifyComplete_SyncWait( PVOID pvContext, CNotifyElement *pElement ){ HANDLE *pTmpHandle = (HANDLE *) pvContext;
DNASSERT( pTmpHandle != NULL );
if( pTmpHandle != NULL && *pTmpHandle != NULL ) { SetEvent( *pTmpHandle ); }}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyComplete_RemotePlayer"
//
// NotifyComplete_RemotePlayer
//
// This is a completion function for when notification of a new remote player has been processed
//
void CDirectVoiceClientEngine::NotifyComplete_RemotePlayer( PVOID pvContext, CNotifyElement *pElement ){ CVoicePlayer *pPlayer = (CVoicePlayer *) pvContext; ASSERT_VPLAYER(pPlayer); PDVMSG_CREATEVOICEPLAYER pCreatePlayer = NULL;
if( pElement->m_etElementType == NOTIFY_DYNAMIC ) { pCreatePlayer = (PDVMSG_CREATEVOICEPLAYER) pElement->m_element.dynamic.m_lpData; } else { pCreatePlayer = (PDVMSG_CREATEVOICEPLAYER) pElement->m_element.fixed.m_bFixedHolder; }
DNASSERT( pPlayer != NULL ); DNASSERT( pCreatePlayer->dwSize == sizeof( DVMSG_CREATEVOICEPLAYER ) );
pPlayer->SetContext( pCreatePlayer->pvPlayerContext ); pPlayer->SetAvailable( TRUE ); pPlayer->Release();}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyComplete_LocalPlayer"
//
// NotifyComplete_LocalPlayer
//
// This is a completion function for when notification of the local player has been processed
//
void CDirectVoiceClientEngine::NotifyComplete_LocalPlayer( PVOID pvContext, CNotifyElement *pElement ){ CDirectVoiceClientEngine *pvEngine = (CDirectVoiceClientEngine *) pvContext;
PDVMSG_CREATEVOICEPLAYER pCreatePlayer = NULL;
if( pElement->m_etElementType == NOTIFY_DYNAMIC ) { pCreatePlayer = (PDVMSG_CREATEVOICEPLAYER) pElement->m_element.dynamic.m_lpData; } else { pCreatePlayer = (PDVMSG_CREATEVOICEPLAYER) pElement->m_element.fixed.m_bFixedHolder; }
DNASSERT( pCreatePlayer->dwSize == sizeof( DVMSG_CREATEVOICEPLAYER ) );
pvEngine->m_pvLocalPlayerContext = pCreatePlayer->pvPlayerContext; pvEngine->m_fLocalPlayerAvailable = TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleCreateVoicePlayer"
//
// HandleCreateVoicePlayer
//
// Validates createvoice player message, source and session type for incoming createvoiceplayer messages.
// If the message is valid, it gets processed.
//
BOOL CDirectVoiceClientEngine::HandleCreateVoicePlayer( DVID dvidSource, PDVPROTOCOLMSG_PLAYERJOIN lpdvCreatePlayer, DWORD dwSize ){ if ( dwSize != sizeof( DVPROTOCOLMSG_PLAYERJOIN ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleCreateVoicePlayer() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
// Prevent createplayer path in non-peer-to-peer sessions
if( m_dvSessionDesc.dwSessionType != DVSESSIONTYPE_PEER ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleCreateVoicePlayer() Ignoring create player in non-peer session from=0x%x", dvidSource ); return FALSE; }
// Prevent createplayer from non-server.
if( dvidSource != m_dvidServer ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleCreateVoicePlayer() Ignoring create player from non-host - from=0x%x", dvidSource ); return FALSE; }
return InternalCreateVoicePlayer( dvidSource, lpdvCreatePlayer, dwSize );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleCreateVoicePlayer"
//
// InternalCreateVoicePlayer
//
// Performs initialization required to create the specified user's record. This function does very little validity checking,
// the CALLER should do this. This should not be called directly from the wire unless the source and state have
// been validated.
//
// Players in the system will normall have a reference count of 3:
// - 1 for playback thread
// - 1 for notify thread
// - 1 for nametable
//
// When a player is added they are added to the nametable as well as the
// pending lists for notify thread and playback thread.
//
// Both of these threads wakeup and:
// - Add any players on the "add list"
// - Remove any players who are marked disconnecting
//
BOOL CDirectVoiceClientEngine::InternalCreateVoicePlayer( DVID dvidSource, PDVPROTOCOLMSG_PLAYERJOIN lpdvCreatePlayer, DWORD dwSize ){ if( !ValidatePlayerFlags( lpdvCreatePlayer->dwFlags ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleCreateVoicePlayer() Ignoring message with invalid player flags, flags=0x%x, from=0x%x", lpdvCreatePlayer->dwFlags, dvidSource ); return FALSE; }
if( !ValidatePlayerDVID( lpdvCreatePlayer->dvidID ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleCreateVoicePlayer() Ignoring message with invalid player dvid, flags=0x%x, from=0x%x", lpdvCreatePlayer->dvidID, dvidSource ); return FALSE; }
if( m_dwCurrentState != DVCSTATE_CONNECTED ) return TRUE;
CVoicePlayer *newPlayer; HRESULT hr; QUEUE_PARAMS queueParams;
hr = m_voiceNameTable.GetEntry( lpdvCreatePlayer->dvidID, &newPlayer, TRUE );
// Ignore duplicate players
if( hr == DV_OK ) { ASSERT_VPLAYER(newPlayer); newPlayer->Release(); return TRUE; }
DPFX(DPFPREP, DVF_CONNECT_PROCEDURE_DEBUG_LEVEL, "Received Create for player ID 0x%x",lpdvCreatePlayer->dvidID );
// Do not both creating a queue or a player entry for ourselves
// Not needed
if( lpdvCreatePlayer->dvidID != m_lpSessionTransport->GetLocalID() ) { DPFX(DPFPREP, DVF_CONNECT_PROCEDURE_DEBUG_LEVEL, "Creating player record" );
newPlayer = (CVoicePlayer*)m_fpPlayers.Get();
if( newPlayer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to allocate new player record. Alloc failure" ); return TRUE; }
ASSERT_VPLAYER(newPlayer); hr = newPlayer->Initialize( lpdvCreatePlayer->dvidID, lpdvCreatePlayer->dwHostOrderID, lpdvCreatePlayer->dwFlags, NULL, &m_fpPlayers );
if( FAILED( hr ) ) { newPlayer->Release(); DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to initialize player record hr=0x%x", hr ); return TRUE; }
queueParams.wFrameSize = m_dwCompressedFrameSize; queueParams.bInnerQueueSize = m_lpdvfCompressionInfo->wInnerQueueSize; queueParams.bMaxHighWaterMark = m_lpdvfCompressionInfo->wMaxHighWaterMark, queueParams.iQuality = m_dvClientConfig.dwBufferQuality; queueParams.iHops = 1; queueParams.iAggr = m_dvClientConfig.dwBufferAggressiveness; queueParams.bInitHighWaterMark = 2; queueParams.wQueueId = lpdvCreatePlayer->dvidID; queueParams.wMSPerFrame = m_lpdvfCompressionInfo->dwTimeout, queueParams.pFramePool = m_pFramePool;
hr = newPlayer->CreateQueue( &queueParams );
if( FAILED( hr ) ) { newPlayer->Release(); DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create queue for player hr=0x%x", hr ); return TRUE; }
hr = m_voiceNameTable.AddEntry( lpdvCreatePlayer->dvidID, newPlayer );
if( FAILED( hr ) ) { // Main ref
newPlayer->Release();
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to add entry to nametable hr=0x%x", hr ); return TRUE; }
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_FORWARDING ) { newPlayer->SetAvailable(TRUE); }
// Add a reference for the player to the "Playback Add List"
DNEnterCriticalSection( &m_csPlayAddList ); newPlayer->AddRef(); newPlayer->AddToPlayList( &m_blPlayAddPlayers ); DNLeaveCriticalSection( &m_csPlayAddList );
// Add a reference for the player to the "Notify Add List"
DNEnterCriticalSection( &m_csNotifyAddList ); newPlayer->AddRef(); newPlayer->AddToNotifyList( &m_blNotifyAddPlayers ); DNLeaveCriticalSection( &m_csNotifyAddList );
// This will now be released by the callback, unless this is multicast
//
// Release our personal reference
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_FORWARDING ) { newPlayer->Release(); } } else { DPFX(DPFPREP, DVF_CONNECT_PROCEDURE_DEBUG_LEVEL, "Local player, no player record required" ); }
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_PEER ) { DVMSG_CREATEVOICEPLAYER dvCreatePlayer; dvCreatePlayer.dvidPlayer = lpdvCreatePlayer->dvidID; dvCreatePlayer.dwFlags = lpdvCreatePlayer->dwFlags; dvCreatePlayer.dwSize = sizeof( DVMSG_CREATEVOICEPLAYER ); dvCreatePlayer.pvPlayerContext = NULL;
// Prevents double notification for local player
if( lpdvCreatePlayer->dvidID != m_lpSessionTransport->GetLocalID() ) { NotifyQueue_Add( DVMSGID_CREATEVOICEPLAYER, &dvCreatePlayer, sizeof( DVMSG_CREATEVOICEPLAYER ), newPlayer, NotifyComplete_RemotePlayer ); } else if( !m_fLocalPlayerNotify ) { // Add local player flag to notification
dvCreatePlayer.dwFlags |= DVPLAYERCAPS_LOCAL;
// Notify of local player (don't create player record)
NotifyQueue_Add( DVMSGID_CREATEVOICEPLAYER, &dvCreatePlayer, sizeof( DVMSG_CREATEVOICEPLAYER ), this, NotifyComplete_LocalPlayer ); m_fLocalPlayerNotify = TRUE; } }
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::MigrateHost_RunElection"
//
// MigrateHost_RunElection
//
// Runs the host migration algorithm
//
HRESULT CDirectVoiceClientEngine::MigrateHost_RunElection( ){ HRESULT hr;
if( m_dwCurrentState == DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: We're disconnecting, no need to run algorithm" ); return TRUE; }
// This shortcut prevents problems if this is called twice.
// But only if we're lucky enough this got set before this poin
// We also have to guard against this case in HostMigrateCreate
//
//
if( m_lpdvServerMigrated != NULL ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Skipping calling removeplayer again as host already migrated" ); return DV_OK; }
DWORD dwHostOrderID = DVPROTOCOL_HOSTORDER_INVALID;
DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Player 0x%x is running election algorithm", this->m_dvidLocal );
// Prevent double-create from host migration run. This can be called by removeplayer and by hostmigrateleave
// message.
CDVCSLock m_guardLock(&m_csClassLock); m_guardLock.Lock();
// Trust me. Do this.
DVID dvidNewHost = m_dvidLocal;
// Check everyone else in the session, see who has lowest host order ID
dwHostOrderID = m_voiceNameTable.GetLowestHostOrderID(&dvidNewHost);
// We're lower then everyone else.. We should become new host
if( m_dwHostOrderID <= dwHostOrderID ) { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: We're to become the new host" ); dvidNewHost = m_dvidLocal; } DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: New Host is [0x%x] OrderID [0x%x] Current [0x%x]", dvidNewHost, dwHostOrderID, m_dwMigrateHostOrderID );
if( m_dwMigrateHostOrderID != DVPROTOCOL_HOSTORDER_INVALID && dwHostOrderID <= m_dwMigrateHostOrderID ) { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: No need to run algorithm again -- in progress (0x%x)", dvidNewHost ); m_guardLock.Unlock(); return DV_OK; }
m_dwMigrateHostOrderID = dwHostOrderID;
m_lpSessionTransport->MigrateHost( dvidNewHost ); m_dvidServer = m_lpSessionTransport->GetServerID(); DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Host is (2) [0x%x]", m_dvidServer );
m_guardLock.Unlock();
// No one was found and we're not properly connected yet
if( dwHostOrderID == DVPROTOCOL_HOSTORDER_INVALID && m_dwCurrentState != DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "There is no one to take over session. Disconnect" );
// We're connecting.. expected behaviour
if( m_dwCurrentState == DVCSTATE_CONNECTING ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Aborting connection..." ); SendConnectResult();
SetEvent( m_hConnectAck );
DoSessionLost(DVERR_SESSIONLOST); } // We're already disconnecting
else if( m_dwCurrentState == DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Already disconnecting.." ); } } // Candidate was found, it's us!
else if( m_dwHostOrderID <= dwHostOrderID ) { // Reset the player list received flag to -1 to allow another playerlist message
InterlockedExchange( &m_iPlayerListReceived, -1 );
DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: We think we're the host! Our Host Order ID=0x%x", m_dwHostOrderID ); hr = HandleLocalHostMigrateCreate();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Host migrate failed hr=0x%x", hr ); } } // Someone was elected -- not us!
//
// We send a settings confirm message in case we ignored host migration message
// during our election. (Small, but reproducable window).
//
// If we do get it after this host may get > 1 settings confirm from us (which is handled).
//
else if( dwHostOrderID != DVPROTOCOL_HOSTORDER_INVALID ) { // Reset the player list received flag to -1 to allow another playerlist message
InterlockedExchange( &m_iPlayerListReceived, -1 );
hr = Send_SettingsConfirm();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Settings confirm message failed! sent hr=0x%x", hr ); }
DVMSG_HOSTMIGRATED dvHostMigrated; dvHostMigrated.dvidNewHostID = m_dvidServer; dvHostMigrated.pdvServerInterface = NULL; dvHostMigrated.dwSize = sizeof( DVMSG_HOSTMIGRATED );
DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Sending notification because of election" ); NotifyQueue_Add( DVMSGID_HOSTMIGRATED, &dvHostMigrated, sizeof( DVMSG_HOSTMIGRATED ) ); }
return DV_OK;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleDeleteVoicePlayer"
//
// HandleDeleteVoicePlayer
//
// Handles the DVMSGID_DELETEVOICEPLAYER message.
//
BOOL CDirectVoiceClientEngine::HandleDeleteVoicePlayer( DVID dvidSource, PDVPROTOCOLMSG_PLAYERQUIT lpdvDeletePlayer, DWORD dwSize ){ CVoicePlayer *pPlayer; HRESULT hr;
if ( dwSize != sizeof( DVPROTOCOLMSG_PLAYERQUIT ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleDeleteVoicePlayer() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
hr = m_voiceNameTable.GetEntry( lpdvDeletePlayer->dvidID, &pPlayer, TRUE );
// If there is a player entry for the given ID,
// Handle removing them from the local player table
if( pPlayer != NULL ) { ASSERT_VPLAYER(pPlayer);
// Remove the entry, this will also drop the reference count
hr = m_voiceNameTable.DeleteEntry( lpdvDeletePlayer->dvidID );
// Another thread has already remove the player -- we don't need to do the rest
// of this.
if( FAILED( hr ) ) { DPFX(DPFPREP, 0, "Error, could not find entry 0x%x to delete hr=0x%x", dvidSource, hr ); pPlayer->Release(); return TRUE; }
// Mark player record as disconnected
pPlayer->SetDisconnected();
// Wait for global object lock and then remove target
// CDVCSLock guardLock(&m_csClassLock);
// guardLock.Lock();
CheckForAndRemoveTarget( lpdvDeletePlayer->dvidID );// guardLock.Unlock();
// If there are any buffers for this player, delete them
// We don't need to destroy them, we want to save them so the user can call
// Delete3DUserBuffer
//
//DeleteSoundTarget( lpdvDeletePlayer->dvidID );
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_PEER ) { DVMSG_DELETEVOICEPLAYER dvMsgDeletePlayer; // Event for doing sync wait
HANDLE hEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
dvMsgDeletePlayer.dvidPlayer = lpdvDeletePlayer->dvidID; dvMsgDeletePlayer.dwSize = sizeof( DVMSG_DELETEVOICEPLAYER ); dvMsgDeletePlayer.pvPlayerContext = pPlayer->GetContext();
pPlayer->SetContext( NULL );
// By making this synchronous we ensure that the voice notification has completed before the dplay8
// callback is called.
//
NotifyQueue_Add( DVMSGID_DELETEVOICEPLAYER, &dvMsgDeletePlayer, sizeof( DVMSG_DELETEVOICEPLAYER ), &hEvent, NotifyComplete_SyncWait );
if( hEvent ) { WaitForSingleObject( hEvent, INFINITE ); CloseHandle( hEvent ); }
}
pPlayer->Release(); }
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::QueueSpeech"
//
// QueueSpeech
//
// Process and queue incoming audio
//
BOOL CDirectVoiceClientEngine::QueueSpeech( DVID dvidSource, PDVPROTOCOLMSG_SPEECHHEADER pdvSpeechHeader, PBYTE pbData, DWORD dwSize ){ CVoicePlayer *pPlayerInfo; HRESULT hr;
// Only start receiving voice if the local player is active
if( !m_fLocalPlayerAvailable ) { DPFX(DPFPREP, 1, "Ignoring incoming audio, local player has not been indicated" ); return TRUE; } hr = m_voiceNameTable.GetEntry( dvidSource, &pPlayerInfo, TRUE );
if( FAILED( hr ) ) { DPFX(DPFPREP, 1, "Received speech for player who is not in nametable hr=0x%x", hr ); return TRUE; }
ASSERT_VPLAYER(pPlayerInfo);
if( !pPlayerInfo->IsAvailable() ) { DPFX(DPFPREP, 1, "Player is not yet available, ignoring speech" ); } else { hr = pPlayerInfo->HandleReceive( pdvSpeechHeader, pbData, dwSize );
if( FAILED( hr ) ) { pPlayerInfo->Release(); DPFX(DPFPREP, 1, "Received speech could not be buffered hr=0x%x", hr ); return TRUE; }
// STATSBLOCK: Begin
m_pStatsBlob->m_dwPRESpeech++; // STATSBLOCK: End
}
// Release our reference to the player
pPlayerInfo->Release(); return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleSpeechWithFrom"
//
// HandleSpeech
//
// Handles speech data messages
//
BOOL CDirectVoiceClientEngine::HandleSpeechWithFrom( DVID dvidSource, PDVPROTOCOLMSG_SPEECHWITHFROM lpdvSpeech, DWORD dwSize ){ HRESULT hr;
// Only valid in forwarding sessions
if( m_dvSessionDesc.dwSessionType != DVSESSIONTYPE_FORWARDING ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeechWithFrom() Ignoring fwd speech message in non-fwd session - from=0x%x", dvidSource ); return FALSE; }
// This messages can only come from the server.
if( dvidSource != m_dvidServer ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeechWithFrom() Ignoring fwd speech message from non-host - from=0x%x", dvidSource ); return FALSE; }
if ( dwSize < sizeof( DVPROTOCOLMSG_SPEECHWITHFROM ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeechWithFrom() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
if( !ValidateSpeechPacketSize( m_lpdvfCompressionInfo, dwSize - sizeof( DVPROTOCOLMSG_SPEECHWITHFROM ) ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeechWithFrom() Ignoring message with invalid speech size, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
if( !ValidatePlayerDVID( lpdvSpeech->dvidFrom ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeechWithFrom() Ignoring message with invalid player dvid, flags=0x%x, from=0x%x", lpdvSpeech->dvidFrom, dvidSource ); return FALSE; } DPFX(DPFPREP, DVF_INFOLEVEL, "Received multicast speech!" );
if( lpdvSpeech->dvidFrom == m_dvidLocal ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Ignoring loopback speech!" ); return TRUE; }
CVoicePlayer *pPlayerInfo;
hr = m_voiceNameTable.GetEntry( lpdvSpeech->dvidFrom, &pPlayerInfo, TRUE ); if( FAILED( hr ) ) { DVPROTOCOLMSG_PLAYERJOIN dvPlayerJoin; dvPlayerJoin.dwFlags = 0; dvPlayerJoin.dvidID = lpdvSpeech->dvidFrom;
// Call internal create voice player handler -- we've done all validation by now.
InternalCreateVoicePlayer( lpdvSpeech->dvidFrom, &dvPlayerJoin, sizeof( DVPROTOCOLMSG_PLAYERJOIN ) ); } else { ASSERT_VPLAYER(pPlayerInfo); pPlayerInfo->Release(); }
return QueueSpeech( lpdvSpeech->dvidFrom, &lpdvSpeech->dvHeader, (PBYTE) &lpdvSpeech[1], dwSize-sizeof(DVPROTOCOLMSG_SPEECHWITHFROM) );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleSpeechBounce"
//
// HandleSpeech
//
// Handles speech data messages
//
BOOL CDirectVoiceClientEngine::HandleSpeechBounce( DVID dvidSource, PDVPROTOCOLMSG_SPEECHHEADER lpdvSpeech, DWORD dwSize ){ if ( dwSize < sizeof( DVPROTOCOLMSG_SPEECHHEADER ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeechBounce() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
if( !ValidateSpeechPacketSize( m_lpdvfCompressionInfo, dwSize - sizeof( DVPROTOCOLMSG_SPEECHHEADER ) ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeechBounce() Ignoring message with invalid speech size, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; } DPFX(DPFPREP, DVF_INFOLEVEL, "Received speech bounce!" );
return QueueSpeech( dvidSource, lpdvSpeech, (PBYTE) &lpdvSpeech[1], dwSize - sizeof( DVPROTOCOLMSG_SPEECHHEADER ) );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleSpeech"
//
// HandleSpeech
//
// Handles speech data messages
//
BOOL CDirectVoiceClientEngine::HandleSpeech( DVID dvidSource, PDVPROTOCOLMSG_SPEECHHEADER lpdvSpeech, DWORD dwSize ){ if ( dwSize < sizeof( DVPROTOCOLMSG_SPEECHHEADER ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeech() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
if( !ValidateSpeechPacketSize( m_lpdvfCompressionInfo, dwSize - sizeof( DVPROTOCOLMSG_SPEECHHEADER ) ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSpeech() Ignoring message with invalid speech size, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; } DPFX(DPFPREP, DVF_INFOLEVEL, "Received bare speech!" );
// Ignore speech from ourselves
if( dvidSource == m_dvidLocal ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Ignoring loopback speech!" ); return TRUE; }
return QueueSpeech( dvidSource, lpdvSpeech, (PBYTE) &lpdvSpeech[1], dwSize - sizeof( DVPROTOCOLMSG_SPEECHHEADER ) );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::Cleanup"
//
// Cleanup
//
// WARNING: Do not call this function multiple times on the same object.
//
// This function shuts down the recording and playback threads, shuts down
// the sound system and unhooks the object from the dplay object.
//
// Called By:
// - DoDisconnect
// - Destructor
// - HandleConnectAccept
// - NotifyThread
//
// Locks Required:
// - Global Write Lock
//
void CDirectVoiceClientEngine::Cleanup(){ DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Cleanup called!" );
// Enter cleanup critical section. Only one instance should be in here at a time.
DNEnterCriticalSection( &m_csCleanupProtect ); CDVCSLock guardLock(&m_csClassLock);
guardLock.Lock();
// We only need to cleanup if we're not idle
if( m_dwCurrentState == DVCSTATE_IDLE ) { DNLeaveCriticalSection( &m_csCleanupProtect ); DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Cleanup not required" ); return; }
if( m_hRecordThreadHandle ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Signalling record to terminate" ); // Signal record thread to shutdown
SetEvent( m_hRecordTerminate );
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Record signalled" );
// Release write lock, if we don't we may have a deadlock
// because recordthread can't get dplay lock, which means
// can't shutdown
//
// Part of a three way deadlock case.
guardLock.Unlock();
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Waiting for record shutdown" ); WaitForSingleObject( m_hRecordDone, INFINITE );
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Record shutdown complete" );
// Re-acquire lock, we need it.
guardLock.Lock();
m_hRecordThreadHandle = NULL; }
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Record cleanup" );
if( m_hRecordTerminate ) { CloseHandle( m_hRecordTerminate ); m_hRecordTerminate = NULL; }
if( m_hRecordDone ) { CloseHandle( m_hRecordDone ); m_hRecordDone = NULL; }
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Record cleanup complete" );
if( m_hPlaybackThreadHandle != NULL ) { // Signal playback thread to shutdown
SetEvent( m_hPlaybackTerminate );
// Release write lock to prevent deadlock.
//
guardLock.Unlock(); WaitForSingleObject( m_hPlaybackDone, INFINITE );
// Re-acquire lock, we need it.
guardLock.Lock();
m_hPlaybackThreadHandle = NULL; }
if( m_hPlaybackTerminate ) { CloseHandle( m_hPlaybackTerminate ); m_hPlaybackTerminate = NULL; }
if( m_hPlaybackDone ) { CloseHandle( m_hPlaybackDone ); m_hPlaybackDone = NULL; } DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Playback Thread Done" );
ClientStats_End();
DPFX(DPFPREP, DVF_INFOLEVEL, "Threads gone!" );
// If we're running in client/server we need destroy the server
// buffer.
if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_MIXING || m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_ECHO ) { DeInitializeClientServer(); DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Client/Server Gone" ); }
guardLock.Unlock();
// Disable notifications, no notifications after this point can be made
NotifyQueue_Disable();
// The following code is extremely sensitive.
//
// Be careful about the order here, it's important.
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Waiting for outstanding sends" ); // Wait for outstanding buffer sends to complete before
// continuing. Otherwise you have potential crash / leak
// condition
WaitForBufferReturns();
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Disconnecting transport" ); // After this function returns DirectPlay will no longer sends
// us indication, but some may still be in progress.
m_lpSessionTransport->DisableReceiveHook( );
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Flushing notification queue" ); // Ensuring that all notifications have been sent
NotifyQueue_Flush();
// Waiting for transport to return all the threads it is indicating into us on.
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Waiting for transport threads to complete" ); m_lpSessionTransport->WaitForDetachCompletion();
// Re-enable notifications
NotifyQueue_Enable();
guardLock.Lock();
if( m_pTimer != NULL ) { delete m_pTimer; m_pTimer = NULL; }
if( m_thTimerInfo.hPlaybackTimerEvent != NULL ) { CloseHandle( m_thTimerInfo.hPlaybackTimerEvent ); m_thTimerInfo.hPlaybackTimerEvent = NULL; }
if( m_thTimerInfo.hRecordTimerEvent != NULL ) { CloseHandle( m_thTimerInfo.hRecordTimerEvent ); m_thTimerInfo.hRecordTimerEvent = NULL; }
CleanupPlaybackLists(); CleanupNotifyLists();
// Inform player of their own exit if they were connected!
if( m_fLocalPlayerNotify ) { DVMSG_DELETEVOICEPLAYER dvMsgDelete; dvMsgDelete.dvidPlayer = m_dvidLocal; dvMsgDelete.dwSize = sizeof( DVMSG_DELETEVOICEPLAYER ); dvMsgDelete.pvPlayerContext = m_pvLocalPlayerContext;
m_pvLocalPlayerContext = NULL; m_fLocalPlayerNotify = FALSE; m_fLocalPlayerAvailable = FALSE;
TransmitMessage( DVMSGID_DELETEVOICEPLAYER, &dvMsgDelete, sizeof( DVMSG_DELETEVOICEPLAYER ) ); } m_voiceNameTable.DeInitialize( (m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_PEER), m_lpUserContext, m_lpMessageHandler);
// Hold off on the shutdown of the sound system so user notifications
// of delete players on unravel of nametable can be handled correctly.
//
ShutdownSoundSystem();
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Sound system shutdown" );
m_fpPlayers.DeInitialize(); FreeBuffers();
if( m_pFramePool != NULL ) { DNEnterCriticalSection( &CDirectVoiceEngine::s_csSTLLock ); delete m_pFramePool; m_pFramePool = NULL; DNLeaveCriticalSection( &CDirectVoiceEngine::s_csSTLLock ); }
SetCurrentState( DVCSTATE_IDLE );
DNEnterCriticalSection( &m_csTargetLock );
if( m_pdvidTargets != NULL ) { delete [] m_pdvidTargets; m_pdvidTargets = NULL; m_dwNumTargets = 0; m_dwTargetVersion = 0; }
DNLeaveCriticalSection( &m_csTargetLock ); DNLeaveCriticalSection( &m_csCleanupProtect );
ClientStats_Dump();
m_pStatsBlob = NULL;
SetEvent( m_hDisconnectAck );
guardLock.Unlock();
if( m_lpdvServerMigrated != NULL ) { m_lpdvServerMigrated->Release(); m_lpdvServerMigrated = NULL; }}
// WaitForBufferReturns
//
// This function waits until oustanding sends have completed before continuing
// we use this to ensure we don't deregister with outstanding sends.
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::WaitForBufferReturns"
void CDirectVoiceClientEngine::WaitForBufferReturns(){ while( 1 ) { if( m_BufferDescPool.GetInUseCount() == 0 ) { break; }
Sleep( 20 ); }
return;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::DoDisconnect"
//
// DoDisconnect
//
// Performs a disconnection and informs the callback function.
//
// Used for both session lost and normal disconnects.
//
// Called By:
// - NotifyThread
//
void CDirectVoiceClientEngine::DoDisconnect(){ // Guard to prevent this function from being called more then once on the
// same object
if( m_dwCurrentState == DVCSTATE_IDLE || m_dwCurrentState == DVCSTATE_NOTINITIALIZED ) return;
// This codeblock ensures that this path will only be run once per connection. Protects against
// multiple disconnect confirm messages sent to the client.
DNEnterCriticalSection( &m_csCleanupProtect );
if( m_fDisconnecting ) { DNLeaveCriticalSection( &m_csCleanupProtect ); return; }
m_fDisconnecting = TRUE;
DNLeaveCriticalSection( &m_csCleanupProtect ); m_dwCurrentState = DVCSTATE_DISCONNECTING; DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "DoDisconnect called!" ); Cleanup();
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Cleanup complete" );
if( m_fSessionLost ) { DVMSG_SESSIONLOST dvSessionLost; dvSessionLost.hrResult = m_hrDisconnectResult; dvSessionLost.dwSize = sizeof( DVMSG_SESSIONLOST ); NotifyQueue_Add( DVMSGID_SESSIONLOST, &dvSessionLost, sizeof( DVMSG_SESSIONLOST ) ); } else { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Signalling disconnect result" ); SendDisconnectResult(); DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Done signalling disconnect" ); }
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Disconnect complete" );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleDisconnect"
// HandleDisconnect
//
// This function is called when a disconnect message is received from the
// server.
//
BOOL CDirectVoiceClientEngine::HandleDisconnectConfirm( DVID dvidSource, PDVPROTOCOLMSG_DISCONNECT lpdvDisconnect, DWORD dwSize ){ if ( dwSize != sizeof( DVPROTOCOLMSG_DISCONNECT ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleDisconnectConfirm() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; }
// Ignore disconnect message from someone who is not the server
if( dvidSource != m_dvidServer ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleDisconnectConfirm() Ignoring disconnect from non-server" ); return FALSE; }
// We're not in the disconnecting state, so this message is irrelevant
if( m_dwCurrentState != DVCSTATE_DISCONNECTING ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleDisconnectConfirm() Ignoring disconnect as we're not disconnecting!" ); return FALSE; } DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "DisconnectConfirm received, signalling worker [res=0x%x]", lpdvDisconnect->hresDisconnect );
DoSignalDisconnect( lpdvDisconnect->hresDisconnect );
DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "DisconnectConfirm received, signalled worker" );
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleSessionLost"
BOOL CDirectVoiceClientEngine::HandleSessionLost( DVID dvidSource, PDVPROTOCOLMSG_SESSIONLOST lpdvSessionLost, DWORD dwSize ){ // This messages can only come from the server.
if( dvidSource != m_dvidServer ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "Ignoring session lost message from non-host - from=0x%x", dvidSource ); return FALSE; }
if ( dwSize != sizeof( DVPROTOCOLMSG_SESSIONLOST ) ) { DPFX( DPFPREP, DVF_ANTIHACK_DEBUG_LEVEL, "DVCE::HandleSessionLost() Ignoring incorrectly sized message, size=0x%x, from=0x%x", dwSize, dvidSource ); return FALSE; } DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::HandleSessionLost() begin" );
DPFX(DPFPREP, DVF_ERRORLEVEL, "<><><><><><><> Session Host has shutdown - Voice Session is gone." );
DoSessionLost( lpdvSessionLost->hresReason );
return TRUE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::StartTransportSession"
HRESULT CDirectVoiceClientEngine::StartTransportSession( ){ return S_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::StopTransportSession"
// StopSession
//
// This function is called when the directplay session is lost or stops
// before DirectXVoice is disconnected.
//
HRESULT CDirectVoiceClientEngine::StopTransportSession(){ DoSessionLost( DVERR_SESSIONLOST );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::AddPlayer"
HRESULT CDirectVoiceClientEngine::AddPlayer( DVID dvID ){ return S_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleLocalHostMigrateCreate"
HRESULT CDirectVoiceClientEngine::HandleLocalHostMigrateCreate(){ LPDIRECTVOICESERVEROBJECT lpdvsServerObject = NULL; DWORD dwSessionSize = 0; HRESULT hr = DP_OK; CDirectVoiceDirectXTransport *pTransport;
// Prevent double-create from host migration run.
CDVCSLock m_guardLock(&m_csClassLock); m_guardLock.Lock();
if( m_lpdvServerMigrated ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Duplicate host create received. Ignoring" ); return DV_OK; }
DPFX(DPFPREP, DVF_ERRORLEVEL, "Local client has become the new host. Creating a host" );
hr = DVS_Create( &lpdvsServerObject );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create server object. hr=0x%x", hr ); goto HOSTCREATE_FAILURE; }
// Grab a reference local of the new host interface
m_lpdvServerMigrated = (LPDIRECTPLAYVOICESERVER) lpdvsServerObject;
m_guardLock.Unlock();
IncrementObjectCount();
lpdvsServerObject->lIntRefCnt++;
DVMSG_LOCALHOSTSETUP dvMsgLocalHostSetup; dvMsgLocalHostSetup.dwSize = sizeof( DVMSG_LOCALHOSTSETUP ); dvMsgLocalHostSetup.pvContext = NULL; dvMsgLocalHostSetup.pMessageHandler = NULL;
TransmitMessage( DVMSGID_LOCALHOSTSETUP, &dvMsgLocalHostSetup, sizeof( DVMSG_LOCALHOSTSETUP ) );
pTransport = (CDirectVoiceDirectXTransport *) m_lpSessionTransport;
hr = DV_Initialize( lpdvsServerObject, pTransport->GetTransportInterface(), dvMsgLocalHostSetup.pMessageHandler, dvMsgLocalHostSetup.pvContext, NULL, 0 );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to initialize the server object hr=0x%x", hr ); goto HOSTCREATE_FAILURE; }
hr = lpdvsServerObject->lpDVServerEngine->HostMigrateStart( &m_dvSessionDesc, m_dwHostOrderID+DVMIGRATE_ORDERID_OFFSET );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error starting server object hr=0x%x", hr ); goto HOSTCREATE_FAILURE; }
DVMSG_HOSTMIGRATED dvHostMigrated; dvHostMigrated.dvidNewHostID = m_lpSessionTransport->GetLocalID(); dvHostMigrated.pdvServerInterface = (LPDIRECTPLAYVOICESERVER) lpdvsServerObject; dvHostMigrated.dwSize = sizeof( DVMSG_HOSTMIGRATED );
NotifyQueue_Add( DVMSGID_HOSTMIGRATED, &dvHostMigrated, sizeof( DVMSG_HOSTMIGRATED ) ); return DV_OK;
HOSTCREATE_FAILURE:
DPFX(DPFPREP, DVF_ERRORLEVEL, "Informing clients of our failure to create host" );
Send_SessionLost();
if( lpdvsServerObject != NULL ) { DVS_Release( lpdvsServerObject ); }
return hr;}
// Handles remove player message
//
// This message triggers handling of host migration if the player
// who has dropped out happens to be the session host.
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::RemovePlayer"
HRESULT CDirectVoiceClientEngine::RemovePlayer( DVID dvID ){ HRESULT hr;
CDVCSLock m_guardLock(&m_csClassLock); m_guardLock.Lock();
if( m_dwCurrentState == DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Ignoring transport disconnect for 0x%x -- client is disconnecting", dvID ); return DV_OK; } m_guardLock.Unlock();
DVPROTOCOLMSG_PLAYERQUIT dvPlayerQuit;
dvPlayerQuit.dwType = DVMSGID_DELETEVOICEPLAYER; dvPlayerQuit.dvidID = dvID;
HandleDeleteVoicePlayer( 0, &dvPlayerQuit, sizeof( DVPROTOCOLMSG_PLAYERQUIT ) );
if( dvID == m_lpSessionTransport->GetServerID() ) { // Don't run host migration code unless it is appropriate
// We could simplify this, but instead using existing code.
DWORD dwTransportSessionType, dwTransportFlags;
hr = m_lpSessionTransport->GetTransportSettings( &dwTransportSessionType, &dwTransportFlags );
if( FAILED( hr ) ) { DNASSERT( FALSE ); DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to retrieve transport settings hr=0x%x", hr ); return DV_OK; } if( (m_dvSessionDesc.dwSessionType != DVSESSIONTYPE_PEER ) || (m_dvSessionDesc.dwFlags & DVSESSION_NOHOSTMIGRATION) || !(dwTransportFlags & DVTRANSPORT_MIGRATEHOST) ) { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Host migration is disabled." ); DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Host is gone. Session will exit soon." );
if( m_dwCurrentState == DVCSTATE_CONNECTING ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Aborting connection..." ); SendConnectResult();
SetEvent( m_hConnectAck ); }
DoSessionLost(DVERR_SESSIONLOST);
return DV_OK; } }
// The person who dropped out was the server
if( dvID == m_lpSessionTransport->GetServerID() ) { DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Checking to see if remove of 0x%x is host 0x%x", dvID, m_lpSessionTransport->GetServerID() ); DPFX(DPFPREP, DVF_HOSTMIGRATE_DEBUG_LEVEL, "HOST MIGRATION: Triggered by Remove Player Message" );
MigrateHost_RunElection(); }
return S_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetCurrentState"
// SetCurrentState
//
// Sets the current state of the client engine
//
void CDirectVoiceClientEngine::SetCurrentState( DWORD dwState ){ CDVCSLock m_guardLock(&m_csClassLock); m_guardLock.Lock(); m_dwCurrentState = dwState; m_guardLock.Unlock();}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CheckShouldSendMessage"
//
// CheckShouldSendMessage
//
// Checks the notification mask to see if the specified message type should
// be sent to the user.
//
BOOL CDirectVoiceClientEngine::CheckShouldSendMessage( DWORD dwMessageType ){ if( m_lpMessageHandler == NULL ) { return FALSE; } BFCSingleLock slLock( &m_csNotifyLock ); slLock.Lock();
BOOL fSend = FALSE;
if( m_dwNumMessageElements == 0 ) { return TRUE; } else { for( DWORD dwIndex = 0; dwIndex < m_dwNumMessageElements; dwIndex++ ) { if( m_lpdwMessageElements[dwIndex] == dwMessageType ) { return TRUE; } } }
return FALSE;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::TransmitMessage"
//
// TransmitMessage
//
// Called to send a notification to the user.
//
// Only the notify thread should call this function, all other threads should queue up
// notifications by calling NotifyQueue_Add.
//
// Called By:
// - NotifyThread.
//
void CDirectVoiceClientEngine::TransmitMessage( DWORD dwMessageType, LPVOID lpData, DWORD dwSize ){ if( CheckShouldSendMessage( dwMessageType ) ) { (*m_lpMessageHandler)( m_lpUserContext, dwMessageType, (!dwSize) ? NULL : lpData ); }}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CheckForDuplicateObjects"
HRESULT CDirectVoiceClientEngine::CheckForDuplicateObjects(){ HRESULT hr; LPKSPROPERTYSET lpksPropSet = NULL; DSPROPERTY_DIRECTSOUND_OBJECTS_DATA* pDSList = NULL; DSPROPERTY_DIRECTSOUNDCAPTURE_OBJECTS_DATA* pDSCList = NULL; DWORD dwIndex; BOOL fFound;
hr = DirectSoundPrivateCreate( &lpksPropSet );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Unable to check for usage of duplicate devices hr=0x%x", hr ); return DV_OK; }
hr = PrvGetDirectSoundObjects( lpksPropSet, GUID_NULL, &pDSList );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Unable to retrieve process sound objs hr=0x%x", hr ); hr = DV_OK; } // Check list for duplicate of the one we are using.
else { // User specified a device, be nice and print a debug message if the object doesn't
// match the GUID
if( m_dvSoundDeviceConfig.lpdsPlaybackDevice != NULL ) { fFound = FALSE; // Check the internal list
for( dwIndex = 0; dwIndex < pDSList->Count; dwIndex++ ) { // Check to see if object user specified matches this one.
if( pDSList->Objects[dwIndex].DirectSound == m_dvSoundDeviceConfig.lpdsPlaybackDevice ) { if( m_dvSoundDeviceConfig.guidPlaybackDevice != pDSList->Objects[dwIndex].DeviceId ) { // Expected behaviour with emulated object
DPFX(DPFPREP, DVF_ERRORLEVEL, "Specified GUID is not correct for specified dsound object" ); fFound = FALSE; } else { fFound = TRUE; DPFX(DPFPREP, DVF_INFOLEVEL, "GUID for device matches object. User param valid" ); } break; } }
// We didn't find specified object in dsound's list.
// Could be an error condition, but would prevent emulated objects from working.
if( !fFound ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Specified DirectSound object does not exist" ); } } // No object specified.
else { // Check the internal list to see if we need to make use of an existing object
for( dwIndex = 0; dwIndex < pDSList->Count; dwIndex++ ) { // We have a winner, a matching playback device.
if( m_dvSoundDeviceConfig.guidPlaybackDevice == pDSList->Objects[dwIndex].DeviceId ) { hr = pDSList->Objects[dwIndex].DirectSound->QueryInterface( IID_IDirectSound, (void **) &m_dvSoundDeviceConfig.lpdsPlaybackDevice );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to retrieve dsound int for existing dsound object hr=0x%x", hr ); hr = DVERR_INVALIDDEVICE;
goto EXIT_SOUND_CHECK; }
break; } } } }
hr = PrvGetDirectSoundCaptureObjects( lpksPropSet, GUID_NULL, &pDSCList );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Unable to retrieve process cap objs hr=0x%x", hr ); hr = DV_OK; } // Check list for duplicate of the one we are using
else { // User specified a device, be nice and print a debug message if the object doesn't
// match the GUID
if( m_dvSoundDeviceConfig.lpdsCaptureDevice != NULL ) { fFound = FALSE; // Check the internal list
for( dwIndex = 0; dwIndex < pDSCList->Count; dwIndex++ ) { // Check to see if object user specified matches this one.
if( pDSCList->Objects[dwIndex].DirectSoundCapture == m_dvSoundDeviceConfig.lpdsCaptureDevice ) { if( m_dvSoundDeviceConfig.guidCaptureDevice != pDSCList->Objects[dwIndex].DeviceId ) { // Expected behaviour with emulated object
DPFX(DPFPREP, DVF_ERRORLEVEL, "Specified GUID is not correct for specified dsound object" ); fFound = FALSE; } else { fFound = TRUE; DPFX(DPFPREP, DVF_INFOLEVEL, "GUID for device matches object. User param valid" ); } break; } }
// We didn't find specified object in dsound's list.
// Could be an error condition, but would prevent emulated objects from working.
if( !fFound ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Specified DirectSoundCap object does not exist" ); } } }
EXIT_SOUND_CHECK:
if( pDSList != NULL ) { delete [] pDSList; }
if( pDSCList != NULL ) { delete [] pDSCList; }
lpksPropSet->Release();
return hr; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::InitializeSoundSystem"
// InitializeSoundSystem
//
// Starts up the sound system based on the parameters.
//
HRESULT CDirectVoiceClientEngine::InitializeSoundSystem(){ HRESULT hr;
Diagnostics_Begin( s_fDumpDiagnostics, "dpv_main.txt" ); DSERRTRACK_Reset();
Diagnostics_DeviceInfo( &m_dvSoundDeviceConfig.guidPlaybackDevice, &m_dvSoundDeviceConfig.guidCaptureDevice );
DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::InitializeSoundSystem() Begin" );
// Note: Mapping of default devices has already been performed.
// On Pre DX7.1 systems, all default devices map to GUID_NULL
// On DX7.1 and later, default device will have been mapped to their real GUIDs
//
m_dwCompressedFrameSize = m_lpdvfCompressionInfo->dwFrameLength; m_dwUnCompressedFrameSize = DVCDB_CalcUnCompressedFrameSize( m_lpdvfCompressionInfo, s_lpwfxPlaybackFormat ); m_dwNumPerBuffer = m_lpdvfCompressionInfo->dwFramesPerBuffer;
// Setup the description for the main playback buffer
//
// Needs to be after above because it depends on proper values above
SetupPlaybackBufferDesc( &m_dsBufferDesc, NULL );
// If they gave us an object, just use it
if( m_dvSoundDeviceConfig.lpdsPlaybackDevice != NULL ) { CDirectSoundPlaybackDevice *tmpDevice; tmpDevice = new CDirectSoundPlaybackDevice( ); if( tmpDevice == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to alloc memory" ); return DVERR_OUTOFMEMORY; }
hr = tmpDevice->Initialize( m_dvSoundDeviceConfig.lpdsPlaybackDevice, m_dvSoundDeviceConfig.guidPlaybackDevice );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error initalizing playback device from specified object hr=0x%x", hr ); delete tmpDevice; return hr; }
m_audioPlaybackDevice = tmpDevice; }
// If they gave us an object, just use it
if( m_dvSoundDeviceConfig.lpdsCaptureDevice != NULL ) { CDirectSoundCaptureRecordDevice *tmpRecDevice; tmpRecDevice = new CDirectSoundCaptureRecordDevice( ); if( tmpRecDevice == NULL ) { if( m_audioPlaybackDevice != NULL ) { delete m_audioPlaybackDevice; m_audioPlaybackDevice = NULL; } Diagnostics_Write( DVF_ERRORLEVEL, "Failed to alloc memory" ); return DVERR_OUTOFMEMORY; }
hr = tmpRecDevice->Initialize( m_dvSoundDeviceConfig.lpdsCaptureDevice, m_dvSoundDeviceConfig.guidCaptureDevice );
if( FAILED( hr ) ) { Diagnostics_Write( DVF_ERRORLEVEL, "Error initializing record device from specified object hr=0x%x", hr ); if( m_audioPlaybackDevice != NULL ) { delete m_audioPlaybackDevice; m_audioPlaybackDevice = NULL; } delete tmpRecDevice; return hr; }
m_audioRecordDevice = tmpRecDevice; }
// We were passed a buffer by the user
if( m_dvSoundDeviceConfig.lpdsMainBuffer ) { m_audioPlaybackBuffer = new CDirectSoundPlaybackBuffer( m_dvSoundDeviceConfig.lpdsMainBuffer );
if( !m_audioPlaybackBuffer ) { Diagnostics_Write( DVF_ERRORLEVEL, "Error allocating memory" );
if( m_audioPlaybackDevice ) { delete m_audioPlaybackDevice; m_audioPlaybackDevice = NULL; }
if( m_audioRecordDevice ) { delete m_audioRecordDevice; m_audioRecordDevice = NULL; }
return DVERR_OUTOFMEMORY; }
DPFX(DPFPREP, DVF_INFOLEVEL, "Creating a buffer using buffer user gave us." ); } // If we haven't initialized half duplex
if( !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX) ) { hr = InitFullDuplex( m_dvSoundDeviceConfig.hwndAppWindow, m_dvSoundDeviceConfig.guidPlaybackDevice, &m_audioPlaybackDevice, &m_dsBufferDesc, &m_audioPlaybackBuffer, m_dvSoundDeviceConfig.guidCaptureDevice, &m_audioRecordDevice, &m_audioRecordBuffer, m_lpdvfCompressionInfo->guidType, this->s_lpwfxPrimaryFormat, this->s_lpwfxPlaybackFormat, this->s_fASO, this->m_dvSoundDeviceConfig.dwMainBufferPriority, this->m_dvSoundDeviceConfig.dwMainBufferFlags, m_dvSoundDeviceConfig.dwFlags );
// Full duplex init failed, set the half duplex flag
if( FAILED( hr ) ) { // Records are deleted here because not needed for half-duplex
if( m_audioRecordDevice != NULL ) { delete m_audioRecordDevice; m_audioRecordDevice = NULL; } if( m_audioRecordBuffer != NULL ) { delete m_audioRecordBuffer; m_audioRecordBuffer = NULL; }
// If we got playbacks from user then let them fall through to half-duplex
// If we allocated them in InitFullDuplex - then it cleans up for itself on error
m_dvSoundDeviceConfig.dwFlags |= DVSOUNDCONFIG_HALFDUPLEX; } // Full duplex passed
else { }
if( hr == E_OUTOFMEMORY ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Full duplex init received an E_OUTOFMEMORY, failing Initialization()." ); return DVERR_OUTOFMEMORY; } }
if( m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX ) { hr = InitHalfDuplex( m_dvSoundDeviceConfig.hwndAppWindow, m_dvSoundDeviceConfig.guidPlaybackDevice, &m_audioPlaybackDevice, &m_dsBufferDesc, &m_audioPlaybackBuffer, m_lpdvfCompressionInfo->guidType, this->s_lpwfxPrimaryFormat, this->s_lpwfxPlaybackFormat, this->m_dvSoundDeviceConfig.dwMainBufferPriority, this->m_dvSoundDeviceConfig.dwMainBufferFlags, m_dvSoundDeviceConfig.dwFlags );
if( FAILED( hr ) ) { // if user supplied these then we need to nuke them here
// if user didn't supply, then they were nuked on error in InitHalfDuplex
if( m_audioPlaybackDevice != NULL ) { delete m_audioPlaybackDevice; m_audioPlaybackDevice = NULL; } if( m_audioPlaybackBuffer != NULL ) { delete m_audioPlaybackBuffer; m_audioPlaybackBuffer = NULL; } return hr; } }
// Build the frame pool
DNEnterCriticalSection( &CDirectVoiceEngine::s_csSTLLock ); m_pFramePool = new CFramePool( m_dwCompressedFrameSize ); DNLeaveCriticalSection( &CDirectVoiceEngine::s_csSTLLock );
m_lpstBufferList = NULL;
if( m_pFramePool == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to allocate frame pool" ); return DVERR_OUTOFMEMORY; }
if (!m_pFramePool->Init()) { delete m_pFramePool; return DVERR_OUTOFMEMORY; }
if( m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_SETCONVERSIONQUALITY ) { if( m_dvSoundDeviceConfig.guidPlaybackDevice != GUID_NULL ) { hr = m_audioPlaybackDevice->GetMixerQuality( &m_dwOriginalPlayQuality );
if( FAILED( hr ) ) { DPFX(DPFPREP, 1, "Unable to get current playback quality hr=0x%x", hr ); m_dwOriginalPlayQuality = DV_CLIENT_SRCQUALITY_INVALID; } // We're already at the setting, someone else probably runinng, disable restore
else if( m_dwOriginalPlayQuality == DIRECTSOUNDMIXER_SRCQUALITY_ADVANCED ) { DPFX(DPFPREP, 1, "Quality setting is already at correct value. Will not set/restore" ); m_dwOriginalPlayQuality = DV_CLIENT_SRCQUALITY_INVALID; } else { hr = m_audioPlaybackDevice->SetMixerQuality( DIRECTSOUNDMIXER_SRCQUALITY_ADVANCED ); } } else { hr = DVERR_NOTSUPPORTED; }
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Unable to set mixer quality for playback device hr=0x%x", hr ); } } else { m_dwOriginalPlayQuality = DV_CLIENT_SRCQUALITY_INVALID; }
// Add a reference for the soundconfig struct if one doesn't exist
if( m_dvSoundDeviceConfig.lpdsPlaybackDevice == NULL ) { m_dvSoundDeviceConfig.lpdsPlaybackDevice = m_audioPlaybackDevice->GetPlaybackDevice(); m_dvSoundDeviceConfig.lpdsPlaybackDevice->AddRef(); }
// If we're not half duplex, do some initial sets for the recording system
if( !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX) && m_audioRecordDevice != NULL ) { if( m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_SETCONVERSIONQUALITY ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Setting quality" ); DV_DUMP_GUID( m_dvSoundDeviceConfig.guidCaptureDevice );
if( m_dvSoundDeviceConfig.lpdsCaptureDevice == NULL ) { m_dvSoundDeviceConfig.lpdsCaptureDevice = m_audioRecordDevice->GetCaptureDevice(); m_dvSoundDeviceConfig.lpdsCaptureDevice->AddRef(); }
if( m_dvSoundDeviceConfig.guidCaptureDevice != GUID_NULL ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Setting quality 2" );
hr = m_audioRecordDevice->GetMixerQuality( &m_dwOriginalRecordQuality );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Unable to get conversion quality hr=0x%x", hr ); m_dwOriginalRecordQuality = DV_CLIENT_SRCQUALITY_INVALID; } // We're already at the setting, someone else probably runinng, disable restore
else if( m_dwOriginalRecordQuality == DIRECTSOUNDMIXER_SRCQUALITY_ADVANCED ) { DPFX(DPFPREP, 1, "Play Quality setting is already at correct value. Will not set/restore" ); m_dwOriginalRecordQuality = DV_CLIENT_SRCQUALITY_INVALID; } else { hr = m_audioRecordDevice->SetMixerQuality( DIRECTSOUNDMIXER_SRCQUALITY_ADVANCED ); } } else { hr = DVERR_NOTSUPPORTED; }
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Setting failed" ); DPFX(DPFPREP, DVF_WARNINGLEVEL, "Unable to set mixer quality for record device hr=0x%x", hr ); } } else { m_dwOriginalRecordQuality = DV_CLIENT_SRCQUALITY_INVALID; }
// If we haven't set no focus
if( !(m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_NOFOCUS ) ) { // Recording is started muted
if( m_dvClientConfig.dwFlags & DVCLIENTCONFIG_RECORDMUTE ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Record Muted: Yielding focus" ); hr = m_audioRecordBuffer->YieldFocus(); } else { DPFX(DPFPREP, DVF_INFOLEVEL, "Record Un-Muted: Attempting to reclaim focus" ); hr = m_audioRecordBuffer->ClaimFocus(); }
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Focus set failed hr=0x%x", hr ); } }
LONG lVolume; hr = m_audioRecordBuffer->GetVolume( &lVolume );
if( FAILED( hr ) ) { Diagnostics_Write( 0, "Unable to retrieve recording volume hr=0x%x", hr ); Diagnostics_Write(0, "Disabling recording controls" ); m_dvSoundDeviceConfig.dwFlags |= DVSOUNDCONFIG_NORECVOLAVAILABLE; } } else { m_dvSoundDeviceConfig.lpdsCaptureDevice = NULL; }
// Initialize the sound target list
InitSoundTargetList();
hr = CreateGeneralBuffer();
if( FAILED( hr ) ) { Diagnostics_Write( 0, "Error creating general buffer hr=0x%x", hr ); return hr; }
DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::InitializeSoundSystem() End" );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ShutdownSoundSystem"
// ShutdownSoundSystem
//
// Stop the sound system
//
HRESULT CDirectVoiceClientEngine::ShutdownSoundSystem(){ DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::ShutdownSoundSystem() Begin" );
HRESULT hr;
FreeSoundTargetList();
#ifndef __DISABLE_SOUND
if( m_audioRecordBuffer != NULL ) { delete m_audioRecordBuffer; m_audioRecordBuffer = NULL; }
if( m_dvSoundDeviceConfig.lpdsMainBuffer != NULL ) { m_dvSoundDeviceConfig.lpdsMainBuffer->Release(); m_dvSoundDeviceConfig.lpdsMainBuffer = NULL; } if( m_audioRecordDevice != NULL ) { if( m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_SETCONVERSIONQUALITY ) { if( m_dwOriginalRecordQuality != DV_CLIENT_SRCQUALITY_INVALID ) { hr = m_audioRecordDevice->SetMixerQuality( m_dwOriginalRecordQuality );
if( FAILED( hr ) ) { DPFX(DPFPREP, 1, "Failed to restore original recording quality hr=0x%x", hr ); } } m_dwOriginalRecordQuality = DV_CLIENT_SRCQUALITY_INVALID; }
delete m_audioRecordDevice;
m_audioRecordDevice = NULL; }
if( m_audioPlaybackBuffer != NULL ) { delete m_audioPlaybackBuffer; m_audioPlaybackBuffer = NULL; }
if( m_audioPlaybackDevice != NULL ) { if( m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_SETCONVERSIONQUALITY ) { if( m_dwOriginalPlayQuality != DV_CLIENT_SRCQUALITY_INVALID ) { hr = m_audioPlaybackDevice->SetMixerQuality( m_dwOriginalPlayQuality );
if( FAILED( hr ) ) { DPFX(DPFPREP, 1, "Failed to restore original playback quality hr=0x%x", hr ); } } m_dwOriginalPlayQuality = DV_CLIENT_SRCQUALITY_INVALID; }
delete m_audioPlaybackDevice; m_audioPlaybackDevice = NULL; }#endif
if( m_dvSoundDeviceConfig.lpdsCaptureDevice != NULL ) { m_dvSoundDeviceConfig.lpdsCaptureDevice->Release(); m_dvSoundDeviceConfig.lpdsCaptureDevice = NULL; }
if( m_dvSoundDeviceConfig.lpdsPlaybackDevice != NULL ) { m_dvSoundDeviceConfig.lpdsPlaybackDevice->Release(); m_dvSoundDeviceConfig.lpdsPlaybackDevice = NULL; } DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::ShutdownSoundSystem() End" );
Diagnostics_End();
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetConnectResult"
// SetConnectResult
//
// This function stores the specified connect result code in m_hrOriginalConnectResult
// and stores the "translated" error code in m_hrConnectResult. m_hrConnectResult
// is used to return the result to the user.
//
// For some error codes the voice layer translates the code to a voice specific error,
// this is why this function is required.
//
void CDirectVoiceClientEngine::SetConnectResult( HRESULT hrConnectResult ){ DPFX( DPFPREP, DVF_CONNECT_PROCEDURE_DEBUG_LEVEL, "CONNECT RESULT: Transition [0x%x] to [0x%x]", m_hrOriginalConnectResult, hrConnectResult ); m_hrOriginalConnectResult = hrConnectResult;
if( HRESULT_FACILITY( hrConnectResult ) == static_cast<HRESULT>(_FACDS) ) { if( hrConnectResult == DSERR_ALLOCATED ) { DPFX( DPFPREP, DVF_WARNINGLEVEL, "WARNING: Mapping DSERR_ALLOCATED --> DVERR_PLAYBACKSYSTEMERROR" ); m_hrConnectResult = DVERR_PLAYBACKSYSTEMERROR; } else if( hrConnectResult == DSERR_OUTOFMEMORY ) { DPFX( DPFPREP, DVF_WARNINGLEVEL, "WARNING: Mapping DSERR_OUTOFMEMORY --> DVERR_OUTOFMEMORY" ); m_hrConnectResult = DVERR_OUTOFMEMORY; } else if( hrConnectResult == DSERR_NODRIVER ) { DPFX( DPFPREP, DVF_WARNINGLEVEL, "WARNING: Mapping DSERR_NODRIVER --> DVERR_INVALIDDEVICE" ); m_hrConnectResult = DVERR_INVALIDDEVICE; } else
{ DPFX( DPFPREP, DVF_WARNINGLEVEL, "WARNING: Mapping 0x%x --> DVERR_SOUNDINITFAILURE", hrConnectResult ); m_hrConnectResult = DVERR_SOUNDINITFAILURE; } } else { m_hrConnectResult = hrConnectResult; }}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetConnectResult"
// GetConnectResult
//
// This function stores the specified connect result code in m_hrOriginalConnectResult
// and stores the "translated" error code in m_hrConnectResult. m_hrConnectResult
// is used to return the result to the user.
//
// For some error codes the voice layer translates the code to a voice specific error,
// this is why this function is required.
//
HRESULT CDirectVoiceClientEngine::GetConnectResult( ) const{ return m_hrConnectResult;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SendConnectResult"
HRESULT CDirectVoiceClientEngine::SendConnectResult(){ if( m_fConnectAsync ) { DVMSG_CONNECTRESULT dvConnect; dvConnect.hrResult = GetConnectResult(); dvConnect.dwSize = sizeof( DVMSG_CONNECTRESULT );
return NotifyQueue_Add( DVMSGID_CONNECTRESULT, &dvConnect, sizeof( DVMSG_CONNECTRESULT ) ); } else { return DV_OK; }}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SendDisconnectResult"
HRESULT CDirectVoiceClientEngine::SendDisconnectResult(){ if( m_fDisconnectAsync ) { DVMSG_DISCONNECTRESULT dvDisconnect; dvDisconnect.hrResult = m_hrDisconnectResult; dvDisconnect.dwSize = sizeof( DVMSG_DISCONNECTRESULT );
return NotifyQueue_Add( DVMSGID_DISCONNECTRESULT, &dvDisconnect, sizeof( DVMSG_DISCONNECTRESULT ) ); } else { return DV_OK; }}
// NotifyThread
//
// All-purpose watch/notification thread.
//
// Wakes up to:
// - Check for multicast player timeout
// - Adjust parameters on notification
// - Sends notification messages to users.
// - Checks for timeouts on connect and disconnect calls
// - Sends level notifications
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyThread"
void CDirectVoiceClientEngine::NotifyThread( void *lpParam ){ CDirectVoiceClientEngine *This = (CDirectVoiceClientEngine *) lpParam;
HANDLE eventArray[5]; DWORD dwWaitPeriod; LONG lWaitResult; DWORD dwPowerLevel; DWORD dwLastLevelNotify, dwLastTimeoutCheck, dwCurTime;
DVMSG_INPUTLEVEL dvInputLevel; DVMSG_OUTPUTLEVEL dvOutputLevel;
dvInputLevel.dwSize = sizeof( DVMSG_INPUTLEVEL ); dvOutputLevel.dwSize = sizeof( DVMSG_OUTPUTLEVEL );
HRESULT hr; DVID dvidMessageTarget;
hr = COM_CoInitialize(NULL);
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error initializing COM" ); SetEvent( This->m_hNotifyDone ); This->HandleThreadError( DVERR_GENERIC ); return; }
eventArray[0] = This->m_hNotifyTerminate; eventArray[1] = This->m_hNotifyChange; eventArray[2] = This->m_hNotifyDisconnect; eventArray[3] = This->m_hNewNotifyElement; eventArray[4] = This->m_hNotifyConnect;
// Setup last times we checked to right now.
dwLastLevelNotify = GetTickCount(); dwLastTimeoutCheck = dwLastLevelNotify; dwWaitPeriod = DV_CLIENT_NOTIFYWAKEUP_TIMEOUT;
while( 1 ) { lWaitResult = WaitForMultipleObjects( 5, eventArray, FALSE, dwWaitPeriod );
DPFX(DPFPREP, DVF_INFOLEVEL, "Wakeing up!" );
// If we were woken up for a reason, handle the reason first
if( lWaitResult != WAIT_TIMEOUT ) { lWaitResult -= WAIT_OBJECT_0;
if( lWaitResult == 0 ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Shutting down" ); break; } else if( lWaitResult == 1 ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Parameter Change" ); } else if( lWaitResult == 2 ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Processing disconnect request" ); This->DoDisconnect(); DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "Finished processing disconnect" ); continue; } else if( lWaitResult == 3 ) { hr = This->NotifyQueue_IndicateNext();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "NotifyQueue_Get Failed hr=0x%x", hr ); } } else if( lWaitResult == 4 ) { if( FAILED( This->GetConnectResult() ) ) { This->Cleanup(); This->SendConnectResult(); SetEvent( This->m_hConnectAck ); } else { This->DoConnectResponse(); } continue; } }
if( This->m_dwCurrentState == DVCSTATE_IDLE ) { continue; }
// If we're connecting, check for timeout on the connection
// request.
if( This->m_dwCurrentState == DVCSTATE_CONNECTING && This->m_dwSynchBegin != 0 ) { dwCurTime = GetTickCount(); if( ( dwCurTime - This->m_dwSynchBegin ) > DV_CLIENT_CONNECT_TIMEOUT ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Connection Timed-Out. Returning NOVOICESESSION" ); This->SetConnectResult( DVERR_NOVOICESESSION ); This->Cleanup(); This->SendConnectResult(); SetEvent( This->m_hConnectAck ); continue; } else if( ( dwCurTime - This->m_dwLastConnectSent ) > DV_CLIENT_CONNECT_RETRY_TIMEOUT ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Connect Request Timed-Out" ); DPFX(DPFPREP, DVF_WARNINGLEVEL, "Re-sending connection request" );
hr = This->Send_ConnectRequest();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error sending connection request. Send error hr=0x%x", hr ); This->SetConnectResult( DVERR_SENDERROR ); This->Cleanup(); This->SendConnectResult(); SetEvent( This->m_hConnectAck ); continue; } This->m_dwLastConnectSent = dwCurTime; } } // If we're disconnecting, check for timeout on the disconnect
else if( This->m_dwCurrentState == DVCSTATE_DISCONNECTING ) { dwCurTime = GetTickCount(); DPFX(DPFPREP, DVF_INFOLEVEL, "Checking timeout on disconnect. Waited %d so far", dwCurTime - This->m_dwSynchBegin ); if( ( dwCurTime - This->m_dwSynchBegin ) > DV_CLIENT_DISCONNECT_TIMEOUT ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Disconnect Request Timed-Out" ); This->DoSignalDisconnect( DVERR_TIMEOUT ); continue; } }
// Take care of the periodic checks
if (This->m_dwCurrentState == DVCSTATE_CONNECTED) { dwCurTime = GetTickCount();
// Update pending / other lists
This->UpdateActiveNotifyPendingList( ); // If we're running a multicast session.. check for timed-out users
if( This->m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_FORWARDING ) { if( ( dwCurTime - dwLastTimeoutCheck ) > DV_MULTICAST_USERTIMEOUT_PERIOD ) { This->CheckForUserTimeout(dwCurTime);
dwLastTimeoutCheck = dwCurTime; } }
// Check to see if it's time to notify about levels
if( This->m_dvClientConfig.dwNotifyPeriod != 0 && This->m_fLocalPlayerAvailable ) { if( ( dwCurTime - dwLastLevelNotify ) > This->m_dvClientConfig.dwNotifyPeriod ) { dvInputLevel.pvLocalPlayerContext = This->m_pvLocalPlayerContext; dvOutputLevel.pvLocalPlayerContext = This->m_pvLocalPlayerContext; if( !(This->m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX) ) { dvInputLevel.dwPeakLevel = This->m_bLastPeak;
if( This->m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_NORECVOLAVAILABLE ) { dvInputLevel.lRecordVolume = DSBVOLUME_MAX; } else { dvInputLevel.lRecordVolume = This->m_dvClientConfig.lRecordVolume; } This->NotifyQueue_Add( DVMSGID_INPUTLEVEL, &dvInputLevel, sizeof( DVMSG_INPUTLEVEL ) ); }
dvOutputLevel.dwPeakLevel = This->m_bLastPlaybackPeak; dvOutputLevel.lOutputVolume = This->m_dvClientConfig.lPlaybackVolume; This->NotifyQueue_Add( DVMSGID_OUTPUTLEVEL, &dvOutputLevel, sizeof( DVMSG_OUTPUTLEVEL ) ); This->SendPlayerLevels(); dwLastLevelNotify = dwCurTime; } } } }
// Flush out any remaining notifications
This->NotifyQueue_Flush();
SetEvent( This->m_hNotifyDone );
COM_CoUninitialize();
_endthread();}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SendPlayerLevels"
//
// SendPlayerLevels
//
// Send player level notifications, but only if there is a message handler
// and the player level message is active.
//
void CDirectVoiceClientEngine::SendPlayerLevels(){ if( CheckShouldSendMessage( DVMSGID_PLAYEROUTPUTLEVEL ) ) { DPFX(DPFPREP, DVF_INFOLEVEL, "SendPlayerLevels: Got Lock" );
CVoicePlayer *pCurrentPlayer; CBilink *pblSearch; DVMSG_PLAYEROUTPUTLEVEL dvPlayerLevel;
pblSearch = m_blNotifyActivePlayers.GetNext();
while( pblSearch != &m_blNotifyActivePlayers ) { pCurrentPlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList ); ASSERT_VPLAYER(pCurrentPlayer);
if( pCurrentPlayer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Retrieved NULL player from active list" ); DNASSERT( FALSE ); return; }
if( pCurrentPlayer->IsReceiving() ) { dvPlayerLevel.dwSize = sizeof( DVMSG_PLAYEROUTPUTLEVEL ); dvPlayerLevel.dvidSourcePlayerID = pCurrentPlayer->GetPlayerID(); dvPlayerLevel.dwPeakLevel = pCurrentPlayer->GetLastPeak(); dvPlayerLevel.pvPlayerContext = pCurrentPlayer->GetContext(); NotifyQueue_Add( DVMSGID_PLAYEROUTPUTLEVEL, &dvPlayerLevel, sizeof( DVMSG_PLAYEROUTPUTLEVEL ) ); }
pblSearch = pblSearch->GetNext(); } }
DPFX(DPFPREP, DVF_INFOLEVEL, "SendPlayerLevels: Done Enum" );
return;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CheckForUserTimeout"
//
// CheckForUserTimeout
//
// Run the list of users and check for user timeouts in multicast sessions
//
void CDirectVoiceClientEngine::CheckForUserTimeout( DWORD dwCurTime ){ DPFX(DPFPREP, DVF_INFOLEVEL, "Got Lock" );
CBilink *pblSearch; CVoicePlayer *pCurrentPlayer; DVPROTOCOLMSG_PLAYERQUIT msgPlayerQuit;
pblSearch = m_blNotifyActivePlayers.GetNext();
msgPlayerQuit.dwType = DVMSGID_DELETEVOICEPLAYER;
while( pblSearch != &m_blNotifyActivePlayers ) { pCurrentPlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList ); ASSERT_VPLAYER(pCurrentPlayer);
if( dwCurTime - pCurrentPlayer->GetLastPlayback() > DV_MULTICAST_USERTIMEOUT_PERIOD ) { msgPlayerQuit.dvidID = pCurrentPlayer->GetPlayerID(); HandleDeleteVoicePlayer( pCurrentPlayer->GetPlayerID(), &msgPlayerQuit, sizeof( DVPROTOCOLMSG_PLAYERQUIT ) ); }
pblSearch = pblSearch->GetNext(); }
DPFX(DPFPREP, DVF_INFOLEVEL, "Done Enum" );
return;}
// Cleanup any outstanding entries on the playback lists
void CDirectVoiceClientEngine::CleanupPlaybackLists( ){ CBilink *pblSearch; CVoicePlayer *pVoicePlayer;
DNEnterCriticalSection( &m_csPlayAddList );
m_dwPlayActiveCount = 0;
pblSearch = m_blPlayActivePlayers.GetNext();
while( pblSearch != &m_blPlayActivePlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList ); ASSERT_VPLAYER(pVoicePlayer);
pVoicePlayer->RemoveFromPlayList(); pVoicePlayer->Release(); pblSearch = m_blPlayActivePlayers.GetNext(); }
pblSearch = m_blPlayAddPlayers.GetNext();
while( pblSearch != &m_blPlayAddPlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList ); ASSERT_VPLAYER(pVoicePlayer);
pVoicePlayer->RemoveFromPlayList(); pVoicePlayer->Release(); pblSearch = m_blPlayAddPlayers.GetNext(); }
DNLeaveCriticalSection( &m_csPlayAddList );}
// Cleanup any outstanding entries on the playback lists
void CDirectVoiceClientEngine::CleanupNotifyLists( ){ CBilink *pblSearch; CVoicePlayer *pVoicePlayer;
DNEnterCriticalSection( &m_csNotifyAddList );
pblSearch = m_blNotifyActivePlayers.GetNext();
while( pblSearch != &m_blNotifyActivePlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList ); ASSERT_VPLAYER(pVoicePlayer);
pVoicePlayer->RemoveFromNotifyList(); pVoicePlayer->Release(); pblSearch = m_blNotifyActivePlayers.GetNext(); }
pblSearch = m_blNotifyAddPlayers.GetNext();
while( pblSearch != &m_blNotifyAddPlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList ); ASSERT_VPLAYER(pVoicePlayer);
pVoicePlayer->RemoveFromNotifyList(); pVoicePlayer->Release(); pblSearch = m_blNotifyAddPlayers.GetNext(); }
DNLeaveCriticalSection( &m_csNotifyAddList );}
// UpdateActivePendingList
//
// This function looks at the pending list and moves those elements on the pending list to the active list
//
// This function also looks at the active list and removes those players who are disconnected
//
// There are three four lists in the system:
// - Playback Thread
// - Notify Thread
// - Host Migration List
//
void CDirectVoiceClientEngine::UpdateActivePlayPendingList( ){ CBilink *pblSearch; CVoicePlayer *pVoicePlayer;
DNEnterCriticalSection( &m_csPlayAddList );
// Add players who are pending
pblSearch = m_blPlayAddPlayers.GetNext();
while( pblSearch != &m_blPlayAddPlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList ); ASSERT_VPLAYER(pVoicePlayer);
pVoicePlayer->RemoveFromPlayList(); pVoicePlayer->AddToPlayList( &m_blPlayActivePlayers ); m_dwPlayActiveCount++;
pblSearch = m_blPlayAddPlayers.GetNext(); }
DNLeaveCriticalSection( &m_csPlayAddList );
// Remove players who have disconnected
pblSearch = m_blPlayActivePlayers.GetNext();
while( pblSearch != &m_blPlayActivePlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList ); ASSERT_VPLAYER(pVoicePlayer);
pblSearch = pblSearch->GetNext();
// If current player has disconnected, remove them from active list
// and release the reference the list has
if( pVoicePlayer->IsDisconnected() ) { m_dwPlayActiveCount--; pVoicePlayer->RemoveFromPlayList(); pVoicePlayer->Release(); } }
}
void CDirectVoiceClientEngine::UpdateActiveNotifyPendingList( ){ CBilink *pblSearch; CVoicePlayer *pVoicePlayer;
DNEnterCriticalSection( &m_csNotifyAddList );
// Add players who are pending
pblSearch = m_blNotifyAddPlayers.GetNext();
while( pblSearch != &m_blNotifyAddPlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList ); ASSERT_VPLAYER(pVoicePlayer);
pVoicePlayer->RemoveFromNotifyList(); pVoicePlayer->AddToNotifyList( &m_blNotifyActivePlayers );
pblSearch = m_blNotifyAddPlayers.GetNext(); }
DNLeaveCriticalSection( &m_csNotifyAddList );
// Remove players who have disconnected
pblSearch = m_blNotifyActivePlayers.GetNext();
while( pblSearch != &m_blNotifyActivePlayers ) { pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList ); ASSERT_VPLAYER(pVoicePlayer);
pblSearch = pblSearch->GetNext();
// If current player has disconnected, remove them from active list
// and release the reference the list has
if( pVoicePlayer->IsDisconnected() ) { pVoicePlayer->RemoveFromNotifyList(); pVoicePlayer->Release(); } }
}
HRESULT CDirectVoiceClientEngine::CreateGeneralBuffer( ){ HRESULT hr;
m_lpstGeneralBuffer = new CSoundTarget( DVID_REMAINING, m_audioPlaybackDevice, (CAudioPlaybackBuffer *) m_audioPlaybackBuffer, &m_dsBufferDesc, m_dvSoundDeviceConfig.dwMainBufferPriority, m_dvSoundDeviceConfig.dwMainBufferFlags, m_dwUnCompressedFrameSize );
if( m_lpstGeneralBuffer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to allocate General Buffer" ); return DVERR_OUTOFMEMORY; } hr = m_lpstGeneralBuffer->GetInitResult();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to initalize general buffer hr=0x%x", hr ); return hr; } if( m_lpstGeneralBuffer->Get3DBuffer() != NULL ) { // Turn off 3D by default on the general buffer
m_lpstGeneralBuffer->Get3DBuffer()->SetMode( DS3DMODE_DISABLE, DS3D_IMMEDIATE ); }
// Set General Buffer Volume
if( m_lpstGeneralBuffer->GetBuffer() != NULL ) { m_lpstGeneralBuffer->GetBuffer()->SetVolume( m_dvClientConfig.lPlaybackVolume ); }
hr = m_lpstGeneralBuffer->StartMix();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to start the mix hr=0x%x.", hr ); return hr; }
return hr;}
// New Playback Thread
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::PlaybackThread"
void CDirectVoiceClientEngine::PlaybackThread( void *lParam ){
DWORD dwCurPlayer; BOOL bContinueEnum; DVPROTOCOLMSG_PLAYERQUIT dvPlayerQuit; DWORD dwResultSize; LPBYTE lpSourceBuffer = NULL; HANDLE hEventArray[2] = { NULL, NULL }; LONG lWaitResult; BOOL fMixed; CSoundTarget *lpstCurrent = NULL; BYTE bHighPeak; HRESULT hr; DWORD dwEchoState; DWORD dwTmp; BYTE bTmpPeak1, bTmpPeak2; DVMSG_PLAYERVOICESTART dvMsgPlayerVoiceStart; DVMSG_PLAYERVOICESTOP dvMsgPlayerVoiceStop; DWORD dwCompressStart; DWORD dwCompressTime; CVoicePlayer *pCurrentPlayer; CBilink *pblSearch; BOOL fSilence, fLost; DWORD dwCurrentTime; DWORD dwSeqNum, dwMsgNum; CFrame *frTmpFrame; DWORD dwCurrentLead = 0; DWORD dwAllowedLeadBuffers = 0; DWORD dwAllowedLeadBytes = 0; DWORD dwHalfBufferSize = 0; BOOL fDesktopCurrent = TRUE;
dvMsgPlayerVoiceStart.dwSize = sizeof( DVMSG_PLAYERVOICESTART ); dvMsgPlayerVoiceStop.dwSize = sizeof( DVMSG_PLAYERVOICESTOP );
CDirectVoiceClientEngine *This = (CDirectVoiceClientEngine *) lParam;
// Pre-calc some sizes..
dwAllowedLeadBuffers = DV_CLIENT_BASE_LEAD_MAX; dwAllowedLeadBytes = This->m_dwUnCompressedFrameSize * DV_CLIENT_BASE_LEAD_MAX; dwHalfBufferSize = This->m_dwUnCompressedFrameSize * (This->m_dwNumPerBuffer/2);
hr = COM_CoInitialize(NULL);
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error initializing COM on playback thread" ); This->HandleThreadError( DVERR_GENERIC ); goto EXIT_PLAYBACK; }
lpSourceBuffer = new BYTE[This->m_dwUnCompressedFrameSize];
if( lpSourceBuffer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to allocate source buffer" ); This->HandleThreadError( DVERR_OUTOFMEMORY ); goto EXIT_PLAYBACK; }
hEventArray[0] = This->m_hPlaybackTerminate; hEventArray[1] = This->m_thTimerInfo.hPlaybackTimerEvent;
if( hEventArray[0] == NULL || hEventArray[1] == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to initialize events" ); This->HandleThreadError( DVERR_GENERIC ); goto EXIT_PLAYBACK; }
if( This->m_audioPlaybackDevice->IsEmulated() ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "WARNING: DirectSound is in emulated mode" ); dwAllowedLeadBuffers += DV_CLIENT_EMULATED_LEAD_ADJUST; dwAllowedLeadBytes += DV_CLIENT_EMULATED_LEAD_ADJUST * This->m_dwUnCompressedFrameSize; } else { DPFX(DPFPREP, DVF_WARNINGLEVEL, "NOTE: DirectSound is in standard mode" ); }
while( 1 ) { lWaitResult = WaitForMultipleObjects( 2, hEventArray, FALSE, INFINITE );
if( lWaitResult == WAIT_OBJECT_0 ) { break; }
hr = This->m_lpstGeneralBuffer->GetCurrentLead( &dwCurrentLead );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to get current position of main buff hr=0x%x", hr ); This->HandleThreadError( hr ); goto EXIT_PLAYBACK; }
while( 1 ) { if( dwCurrentLead < (dwAllowedLeadBytes) ) { DPFX(DPFPREP, DVF_INFOLEVEL, "PWI, Lead: %d Running a pass..", dwCurrentLead ); } else if( dwCurrentLead > dwHalfBufferSize ) { DPFX(DPFPREP, DVF_INFOLEVEL, "PWI, Lead: %d Running a pass (wraparound)..", dwCurrentLead ); } else { DPFX(DPFPREP, DVF_INFOLEVEL, "PWI, Lead: %d NOT Running a pass..", dwCurrentLead ); break; }
DNEnterCriticalSection( &This->m_thTimerInfo.csPlayCount );
// Only run a max of two times per iteration
if( This->m_thTimerInfo.lPlaybackCount > dwAllowedLeadBuffers ) This->m_thTimerInfo.lPlaybackCount = dwAllowedLeadBuffers; else This->m_thTimerInfo.lPlaybackCount--;
DNLeaveCriticalSection( &This->m_thTimerInfo.csPlayCount );
#ifdef WINNT
fDesktopCurrent = ( USER_SHARED_DATA->ActiveConsoleId == NtCurrentPeb()->SessionId);#endif
bHighPeak = 0;
// Update list
This->UpdateActivePlayPendingList( );
if( This->m_dvClientConfig.dwFlags & DVCLIENTCONFIG_ECHOSUPPRESSION ) { DNEnterCriticalSection( &This->m_lockPlaybackMode ); dwEchoState = This->m_dwEchoState;
DNLeaveCriticalSection( &This->m_lockPlaybackMode ); } else { dwEchoState = DVCECHOSTATE_IDLE; }
if( dwEchoState != DVCECHOSTATE_RECORDING ) { dwCurrentTime = GetTickCount();
pblSearch = This->m_blPlayActivePlayers.GetNext();
while( pblSearch != &This->m_blPlayActivePlayers ) { pCurrentPlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList ); ASSERT_VPLAYER(pCurrentPlayer);
pblSearch = pblSearch->GetNext();
dwResultSize = This->m_dwUnCompressedFrameSize;
dwCompressStart = GetTickCount();
if( !pCurrentPlayer->IsInBoundConverterInitialized() ) { hr = pCurrentPlayer->CreateInBoundConverter( This->m_lpdvfCompressionInfo->guidType, s_lpwfxPlaybackFormat );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to get create converter for player hr=0x%x", hr ); This->HandleThreadError( DVERR_GENERIC ); goto EXIT_PLAYBACK; } }
if( This->m_dvClientConfig.dwFlags & DVCLIENTCONFIG_PLAYBACKMUTE || !fDesktopCurrent ) { frTmpFrame = pCurrentPlayer->Dequeue(&fLost, &fSilence); frTmpFrame->Return(); continue; }
hr = pCurrentPlayer->GetNextFrameAndDecompress( lpSourceBuffer, &dwResultSize, &fLost, &fSilence, &dwSeqNum, &dwMsgNum );
// If bad speech packet is constructed so it caused compressor to fail, it's ignored.
// Old code dropped us from the session, which would allow remote clients to drop
// us with a single packet.
if( FAILED( hr ) ) { dwSeqNum = 0; dwMsgNum = 0; fLost = FALSE; fSilence = TRUE; }
dwCompressTime = GetTickCount() - dwCompressStart;
// STATSBLOCK: Begin
This->m_pStatsBlob->m_dwPDTTotal += dwCompressTime;
if( dwCompressTime < This->m_pStatsBlob->m_dwPDTMin ) { This->m_pStatsBlob->m_dwPDTMin = dwCompressTime; }
if( dwCompressTime > This->m_pStatsBlob->m_dwPDTMax ) { This->m_pStatsBlob->m_dwPDTMax = dwCompressTime; }
// STATSBLOCK: End
// STATSBLOCK: Begin
if( fLost ) { DPFX(DPFPREP, DVF_CLIENT_SEQNUM_DEBUG_LEVEL, "SEQ: Dequeue: Lost Frame" ); DPFX(DPFPREP, DVF_GLITCH_DEBUG_LEVEL, "GLITCH: Dequeue: Packet was lost. Speech gap will occur." ); This->m_pStatsBlob->m_dwPPDQLost++; } else if( fSilence ) { DPFX(DPFPREP, DVF_CLIENT_SEQNUM_DEBUG_LEVEL, "SEQ: Dequeue: Silent Frame" ); This->m_pStatsBlob->m_dwPPDQSilent++; } else { DPFX(DPFPREP, DVF_CLIENT_SEQNUM_DEBUG_LEVEL, "SEQ: Dequeue: Msg [%d] Seq [%d]", dwMsgNum, dwSeqNum ); This->m_pStatsBlob->m_dwPPDQSpeech++; } // STATSBLOCK: End
// If the player sent us silence, increment the silent count
if( fSilence ) { // If we're receiving on this user
if( pCurrentPlayer->IsReceiving() ) { // If it exceeds the max.
if( (dwCurrentTime - pCurrentPlayer->GetLastPlayback()) > PLAYBACK_RECEIVESTOP_TIMEOUT ) { pCurrentPlayer->SetReceiving(FALSE);
dvMsgPlayerVoiceStop.dwSize = sizeof( dvMsgPlayerVoiceStop ); dvMsgPlayerVoiceStop.dvidSourcePlayerID = pCurrentPlayer->GetPlayerID(); dvMsgPlayerVoiceStop.pvPlayerContext = pCurrentPlayer->GetContext(); This->NotifyQueue_Add( DVMSGID_PLAYERVOICESTOP, &dvMsgPlayerVoiceStop, sizeof( dvMsgPlayerVoiceStop ) ); This->m_dwActiveCount--;
if( This->m_dwActiveCount == 0 ) { if( This->m_dvClientConfig.dwFlags & DVCLIENTCONFIG_ECHOSUPPRESSION ) { DNEnterCriticalSection( &This->m_lockPlaybackMode );
if( This->m_dwEchoState == DVCECHOSTATE_PLAYBACK ) { DPFX(DPFPREP, PLAYBACK_SWITCH_DEBUG_LEVEL, "%%%% Switching to idle mode" ); This->m_dwEchoState = DVCECHOSTATE_IDLE; }
DNLeaveCriticalSection( &This->m_lockPlaybackMode ); } } } } } else { // We receive data and this is the first one
if( !pCurrentPlayer->IsReceiving() ) { dvMsgPlayerVoiceStart.dvidSourcePlayerID = pCurrentPlayer->GetPlayerID(); dvMsgPlayerVoiceStart.pvPlayerContext = pCurrentPlayer->GetContext(); This->NotifyQueue_Add( DVMSGID_PLAYERVOICESTART, &dvMsgPlayerVoiceStart, sizeof(DVMSG_PLAYERVOICESTART) ); This->m_dwActiveCount++; if( This->m_dwActiveCount == 1 ) { if( This->m_dvClientConfig.dwFlags & DVCLIENTCONFIG_ECHOSUPPRESSION ) { DNEnterCriticalSection( &This->m_lockPlaybackMode ); if( This->m_dwEchoState == DVCECHOSTATE_IDLE ) { DPFX(DPFPREP, PLAYBACK_SWITCH_DEBUG_LEVEL, "%%%% Switching to playback mode" ); This->m_dwEchoState = DVCECHOSTATE_PLAYBACK; }
DNLeaveCriticalSection( &This->m_lockPlaybackMode ); } } pCurrentPlayer->SetReceiving(TRUE); } }
fMixed = FALSE;
// If the frame was not silence, decompress it and then
// mix it into the mixer buffer
if( !fSilence && fDesktopCurrent && !(This->m_dvClientConfig.dwFlags & DVCLIENTCONFIG_PLAYBACKMUTE) ) { DPFX(DPFPREP, DVF_INFOLEVEL, "Player: 0x%x getting frame.. it's speech", pCurrentPlayer->GetPlayerID() );
// Lock the buffer list
DNEnterCriticalSection( &This->m_csBufferLock );
lpstCurrent = This->m_lpstBufferList;
if( pCurrentPlayer->GetLastPeak() > bHighPeak ) { bHighPeak = pCurrentPlayer->GetLastPeak(); }
// Loop through list looking for buffers to mix into
while( lpstCurrent != NULL ) { if( lpstCurrent->GetTarget() == pCurrentPlayer->GetPlayerID() ) { lpstCurrent->MixInSingle( lpSourceBuffer ); fMixed = TRUE; } else if( This->m_lpSessionTransport->IsPlayerInGroup( lpstCurrent->GetTarget(), pCurrentPlayer->GetPlayerID() ) ) { lpstCurrent->MixIn( lpSourceBuffer ); fMixed = TRUE; }
lpstCurrent = lpstCurrent->m_lpstNext; }
DNLeaveCriticalSection( &This->m_csBufferLock );
if( !(This->m_dvClientConfig.dwFlags & DVCLIENTCONFIG_MUTEGLOBAL) ) { // If we didn't mix into any user created buffers, then
// Mix into the main buffer
if( !fMixed ) { if( This->m_dwPlayActiveCount == 1 ) { hr = This->m_lpstGeneralBuffer->MixInSingle( lpSourceBuffer ); } else { hr = This->m_lpstGeneralBuffer->MixIn( lpSourceBuffer ); }
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to do mix." );
DNLeaveCriticalSection( &This->m_csBufferLock ); This->HandleThreadError( hr ); goto EXIT_PLAYBACK; } } }
} else { DPFX(DPFPREP, DVF_INFOLEVEL, "Player: 0x%x getting frame.. it's silence", pCurrentPlayer->GetPlayerID() ); } } // for each player
} // not in the recording state and at least one talking
else { bHighPeak = 0; }
// Lock the buffer list
DNEnterCriticalSection( &This->m_csBufferLock );
lpstCurrent = This->m_lpstBufferList;#if defined(DEBUG) || defined(DBG)
This->CHECKLISTINTEGRITY();#endif
// Loop through list looking for buffers to mix into
while( lpstCurrent != NULL ) {#if defined(DEBUG) || defined(DBG)
This->CHECKLISTINTEGRITY();#endif
hr = lpstCurrent->Commit();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error commiting to buffer hr=0x%x -- Locked by user?", hr ); DNLeaveCriticalSection( &This->m_csBufferLock );
if( hr == DSERR_NODRIVER ) { hr = DVERR_INVALIDDEVICE; } else { hr = DVERR_LOCKEDBUFFER; }
This->HandleThreadError( hr ); goto EXIT_PLAYBACK; }
lpstCurrent = lpstCurrent->m_lpstNext; }
This->m_bLastPlaybackPeak = bHighPeak;
hr = This->m_lpstGeneralBuffer->Commit();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error commiting to buffer hr=0x%x -- Locked by user?", hr ); DNLeaveCriticalSection( &This->m_csBufferLock );
if( hr == DSERR_NODRIVER ) { hr = DVERR_INVALIDDEVICE; } else { hr = DVERR_LOCKEDBUFFER; } This->HandleThreadError( hr ); goto EXIT_PLAYBACK; }
DNLeaveCriticalSection( &This->m_csBufferLock );
hr = This->m_lpstGeneralBuffer->GetCurrentLead( &dwCurrentLead );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to get current pos of main buffer hr=0x%x", hr ); This->HandleThreadError( hr ); goto EXIT_PLAYBACK; } } }
EXIT_PLAYBACK:
DPFX(DPFPREP, DVF_INFOLEVEL, "PT: Exiting" );
// Stop the playback
//This->m_audioPlaybackBuffer->Stop();
// Deallocate the buffers
DPFX(DPFPREP, DVF_INFOLEVEL, "PT: mixer gone" );
if( lpSourceBuffer != NULL ) { delete [] lpSourceBuffer; } DPFX(DPFPREP, DVF_INFOLEVEL, "PT: source gone" );
// Signal that thread is done.
SetEvent( This->m_hPlaybackDone );
DPFX(DPFPREP, DVF_INFOLEVEL, "PT: Shutdown complete" );
COM_CoUninitialize();
_endthread();}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetPlaybackVolume"
//
// SetPlaybackVolume
//
// Sets the playback volume of all the playback buffers
//
HRESULT CDirectVoiceClientEngine::SetPlaybackVolume( LONG lVolume ){ CSoundTarget *lpstCurrent; CAudioPlaybackBuffer *lpdsBuffer; m_audioPlaybackBuffer->SetVolume( lVolume );
// Lock the buffer list
DNEnterCriticalSection( &m_csBufferLock );
lpstCurrent = m_lpstBufferList;
// Loop through list of buffers setting the volume
while( lpstCurrent != NULL ) { lpdsBuffer = lpstCurrent->GetBuffer();
if( lpdsBuffer != NULL ) { lpdsBuffer->SetVolume( lVolume ); }
lpstCurrent = lpstCurrent->m_lpstNext; }
// Lock the buffer list
DNLeaveCriticalSection( &m_csBufferLock );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::HandleThreadError"
//
// HandleThreadError
//
// Handles errors within threads. When an error occurs this function sets the
// session lost flag and notifies the notifythread to perform a disconnect.
//
void CDirectVoiceClientEngine::HandleThreadError( HRESULT hrResult ){ DoSessionLost( hrResult );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::RecordThread"
// RecordThread
//
// Thread to handle compression / transmission
//
void CDirectVoiceClientEngine::RecordThread( void *lpParam ) { CDirectVoiceClientEngine *This = (CDirectVoiceClientEngine *) lpParam;
DNASSERT( This != NULL );
DPFX(DPFPREP, DVF_ENTRYLEVEL, "DVCE::RecordThread() Begin" );
HANDLE hEventArray[2]; LONG lWaitResult; HRESULT hr; BOOL fContinue = FALSE; DWORD dwNumRunsPerWakeup = 0; CClientRecordSubSystem *subSystem = NULL;
hr = COM_CoInitialize(NULL);
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error innitializing COM on record thread" ); goto EXIT_ERROR; }
subSystem = new CClientRecordSubSystem( This );
// Check that the converter is valid
if( subSystem == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Memory alloc failure" ); goto EXIT_ERROR; }
hr = subSystem->Initialize();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Record Sub Error during init hr=0x%x", hr ); goto EXIT_ERROR; }
hEventArray[0] = This->m_hRecordTerminate; hEventArray[1] = This->m_thTimerInfo.hRecordTimerEvent;
// Loop while we're connected
while( 1 ) { lWaitResult = WaitForMultipleObjects( 2, hEventArray, FALSE, INFINITE );
This->m_pStatsBlob->m_recStats.m_dwNumWakeups++;
if( lWaitResult == WAIT_OBJECT_0 ) { break; }
fContinue = TRUE;
dwNumRunsPerWakeup = 0;
while( fContinue ) { // Wait for next frame, if this fails recording
// system is locked. Return
hr = subSystem->GetNextFrame( &fContinue );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to retrieve next frame hr = 0x%x", hr ); goto EXIT_ERROR; }
if( !fContinue ) { ResetEvent( This->m_thTimerInfo.hRecordTimerEvent ); break; } This->m_pStatsBlob->m_recStats.m_dwRPWTotal++; dwNumRunsPerWakeup++;
DPFX(DPFPREP, DVF_INFOLEVEL, "> RTAR: Got" );
hr = subSystem->RecordFSM();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to update FSM hr=0x%x", hr ); goto EXIT_ERROR; }
DPFX(DPFPREP, DVF_INFOLEVEL, "> RTAR: FSM" ); // Transmit the frame if need be.
hr = subSystem->TransmitFrame();
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "TransmitFrame Failed hr=0x%x", hr ); goto EXIT_ERROR; }
DPFX(DPFPREP, DVF_INFOLEVEL, "> RTAR: Trans" ); }
if( dwNumRunsPerWakeup < This->m_pStatsBlob->m_recStats.m_dwRPWMin ) { This->m_pStatsBlob->m_recStats.m_dwRPWMin = dwNumRunsPerWakeup; }
if( dwNumRunsPerWakeup > This->m_pStatsBlob->m_recStats.m_dwRPWMax ) { This->m_pStatsBlob->m_recStats.m_dwRPWMax = dwNumRunsPerWakeup; } }
// Delete the recording subsystem
delete subSystem;
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Record Sub Gone" );
COM_CoUninitialize();
SetEvent( This->m_hRecordDone );
DPFX(DPFPREP, DVF_ENTRYLEVEL, "Record Gone" );
return;
EXIT_ERROR:
if( subSystem ) delete subSystem;
This->HandleThreadError( DVERR_RECORDSYSTEMERROR );
COM_CoUninitialize();
SetEvent( This->m_hRecordDone );
_endthread();}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::MigrateHost"
// MigrateHost
//
// This function is called by DV_HostMigrate when the local client has received a host
// migration notification.
//
//
HRESULT CDirectVoiceClientEngine::MigrateHost( DVID dvidNewHost, LPDIRECTPLAYVOICESERVER lpdvServer ){ return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_Flush"
//
// NotifyQueue_Flush
//
// This function does not return until all notifications have been indicated
//
void CDirectVoiceClientEngine::NotifyQueue_Flush(){ BFCSingleLock slLock( &m_csNotifyQueueLock ); slLock.Lock(); while( m_lpNotifyList ) { NotifyQueue_IndicateNext(); }}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_IndicateNext"
HRESULT CDirectVoiceClientEngine::NotifyQueue_IndicateNext(){ HRESULT hr; CNotifyElement *neElement; hr = NotifyQueue_Get( &neElement );
if( FAILED( hr ) ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "NotifyQueue_Get Failed hr=0x%x", hr ); } else { DPFX(DPFPREP, DVF_INFOLEVEL, "Sending notification type=0x%x", neElement->m_dwType );
if( neElement->m_etElementType == NOTIFY_FIXED ) { TransmitMessage( neElement->m_dwType, &neElement->m_element.fixed, neElement->m_dwDataSize ); } else { TransmitMessage( neElement->m_dwType, neElement->m_element.dynamic.m_lpData, neElement->m_dwDataSize ); }
DPFX(DPFPREP, DVF_INFOLEVEL, "Returning notification" );
NotifyQueue_ElementFree( neElement ); }
return hr;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_Add"
// Queue up a notification for the user
HRESULT CDirectVoiceClientEngine::NotifyQueue_Add( DWORD dwMessageType, LPVOID lpData, DWORD dwDataSize, PVOID pvContext, CNotifyElement::PNOTIFY_COMPLETE pNotifyFunc ){ BFCSingleLock slLock( &m_csNotifyQueueLock ); slLock.Lock();
if( !m_fNotifyQueueEnabled ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Ignoring indication, queue disabled" ); }
CNotifyElement *lpNewElement;
HRESULT hr;
lpNewElement = (CNotifyElement *) m_fpNotifications.Get( );
if( lpNewElement == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Failed to get a block for a notifier" ); return DVERR_OUTOFMEMORY; }
// Setup the notification callbacks, if there are ones
lpNewElement->pvContext = pvContext; lpNewElement->pNotifyFunc = pNotifyFunc;
if( dwMessageType == DVMSGID_PLAYERVOICESTOP ) { const DVMSG_PLAYERVOICESTOP* pMsgStop = (PDVMSG_PLAYERVOICESTOP) lpData;
DNASSERT( pMsgStop->dwSize == sizeof( DVMSG_PLAYERVOICESTOP ) ); DNASSERT( dwDataSize == sizeof( DVMSG_PLAYERVOICESTOP ) ); }
if( dwMessageType == DVMSGID_PLAYERVOICESTART ) { const DVMSG_PLAYERVOICESTART* pMsgStart = (PDVMSG_PLAYERVOICESTART) lpData;
DNASSERT( pMsgStart->dwSize == sizeof( DVMSG_PLAYERVOICESTART ) ); DNASSERT( dwDataSize == sizeof( DVMSG_PLAYERVOICESTART ) ); }
if( dwMessageType == DVMSGID_PLAYEROUTPUTLEVEL ) { const DVMSG_PLAYEROUTPUTLEVEL* pMsgOutput = (PDVMSG_PLAYEROUTPUTLEVEL) lpData;
DNASSERT( pMsgOutput->dwSize == sizeof( DVMSG_PLAYEROUTPUTLEVEL ) ); DNASSERT( dwDataSize == sizeof( DVMSG_PLAYEROUTPUTLEVEL ) ); }
lpNewElement->m_lpNext = m_lpNotifyList; lpNewElement->m_dwType = dwMessageType; lpNewElement->m_dwDataSize = dwDataSize;
if( dwDataSize <= DV_CLIENT_NOTIFY_ELEMENT_SIZE ) { lpNewElement->m_etElementType = NOTIFY_FIXED; } else { lpNewElement->m_etElementType = NOTIFY_DYNAMIC; }
if( lpNewElement->m_etElementType == NOTIFY_FIXED ) { memcpy( &lpNewElement->m_element.fixed, lpData, dwDataSize ); } else if( lpNewElement->m_etElementType == NOTIFY_DYNAMIC ) { lpNewElement->m_element.dynamic.m_lpData = new BYTE[dwDataSize];
if( lpNewElement->m_element.dynamic.m_lpData == NULL ) { m_fpNotifications.Release( lpNewElement );
DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to alloc memory for notification" );
return DVERR_OUTOFMEMORY; }
memcpy( lpNewElement->m_element.dynamic.m_lpData, lpData, dwDataSize ); } else { DNASSERT( FALSE ); }
// Fixups for internal pointers
//
// Required for certain message types (currently only DVMSGID_SETTARGETS)
if( dwMessageType == DVMSGID_SETTARGETS ) { PDVMSG_SETTARGETS pdvSetTarget;
if( lpNewElement->m_etElementType == NOTIFY_FIXED ) { pdvSetTarget = (PDVMSG_SETTARGETS) &lpNewElement->m_element.fixed; } else { pdvSetTarget = (PDVMSG_SETTARGETS) lpNewElement->m_element.dynamic.m_lpData; }
pdvSetTarget->pdvidTargets = (PDVID) &pdvSetTarget[1]; lpNewElement->m_dwDataSize = sizeof( DVMSG_SETTARGETS ); }
// We're ignoring this notification, call the completion immediately.
if( !m_fNotifyQueueEnabled ) { DPFX(DPFPREP, DVF_WARNINGLEVEL, "Ignoring notification, calling completion immediately" ); NotifyQueue_ElementFree( lpNewElement ); return DV_OK; }
m_lpNotifyList = lpNewElement;
ReleaseSemaphore( m_hNewNotifyElement, 1, NULL );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_Get"
// Retrieve the next element in our queue.
//
// If there is an element, return DV_OK, otherwise DVERR_GENERIC.
//
HRESULT CDirectVoiceClientEngine::NotifyQueue_Get( CNotifyElement **pneElement ){ BFCSingleLock slLock( &m_csNotifyQueueLock ); slLock.Lock();
CNotifyElement *lpIterator = m_lpNotifyList; CNotifyElement *lpTrailIterator = NULL;
if( lpIterator == NULL ) return DVERR_GENERIC;
// Move forward to the last element in the list
while( lpIterator->m_lpNext != NULL ) { lpTrailIterator = lpIterator; lpIterator = lpIterator->m_lpNext; }
*pneElement = lpIterator;
// Remove the last element in the list
// Special case, only element on the list
if( lpTrailIterator == NULL ) { m_lpNotifyList = NULL; } else { lpTrailIterator->m_lpNext = NULL; }
return DV_OK;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_Init"
HRESULT CDirectVoiceClientEngine::NotifyQueue_Init(){ BFCSingleLock slLock( &m_csNotifyQueueLock ); slLock.Lock();
if (!m_fpNotifications.Initialize( sizeof( CNotifyElement ), NULL, NULL, NULL, NULL )) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create fixed pool for notify elements" ); return DVERR_OUTOFMEMORY; } m_lpNotifyList = NULL; m_hNewNotifyElement = CreateSemaphore( NULL, 0, DVCLIENT_NOTIFY_MAXSEMCOUNT, NULL );
if (m_hNewNotifyElement==NULL) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Unable to create semaphore for notify elements" ); return DVERR_GENERIC; } m_fNotifyQueueEnabled = TRUE;
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_Enable"
void CDirectVoiceClientEngine::NotifyQueue_Enable(){ BFCSingleLock slLock( &m_csNotifyQueueLock ); slLock.Lock();
m_fNotifyQueueEnabled = TRUE; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_Disable"
void CDirectVoiceClientEngine::NotifyQueue_Disable(){ BFCSingleLock slLock( &m_csNotifyQueueLock ); slLock.Lock(); m_fNotifyQueueEnabled = FALSE; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_ElementFree"
HRESULT CDirectVoiceClientEngine::NotifyQueue_ElementFree( CNotifyElement *lpElement ){ // Call the notification function, if there is one
if( lpElement->pNotifyFunc ) { (*lpElement->pNotifyFunc)(lpElement->pvContext,lpElement); lpElement->pNotifyFunc = NULL; lpElement->pvContext = NULL; } // If this element is dynamic free the associated memory
if( lpElement->m_etElementType == NOTIFY_DYNAMIC ) { delete [] lpElement->m_element.dynamic.m_lpData; } // Return notifier to the fixed pool manager
m_fpNotifications.Release( lpElement );
return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::NotifyQueue_Free"
HRESULT CDirectVoiceClientEngine::NotifyQueue_Free(){ BFCSingleLock slLock( &m_csNotifyQueueLock ); slLock.Lock();
CNotifyElement *lpTmpElement; CNotifyElement *lpIteratorElement;
lpIteratorElement = m_lpNotifyList;
while( lpIteratorElement != NULL ) { lpTmpElement = lpIteratorElement; lpIteratorElement = lpIteratorElement->m_lpNext;
NotifyQueue_ElementFree( lpTmpElement ); }
if( m_hNewNotifyElement != NULL ) { CloseHandle( m_hNewNotifyElement ); }
if (m_fNotifyQueueEnabled) { m_fpNotifications.DeInitialize(); }
return DV_OK;}
//
// HANDLERS FOR WHEN WE HANDLE REMOTE SERVERS
//
//
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::CreateGroup"
HRESULT CDirectVoiceClientEngine::CreateGroup( DVID dvID ){ return S_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::DeleteGroup"
HRESULT CDirectVoiceClientEngine::DeleteGroup( DVID dvID ){ CheckForAndRemoveTarget( dvID );
// If there are any buffers for this player, delete them
//
// Leave the buffer around so the user can call Delete3DSoundBuffer
//
// DeleteSoundTarget( dvID );
return S_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::AddPlayerToGroup"
HRESULT CDirectVoiceClientEngine::AddPlayerToGroup( DVID dvidGroup, DVID dvidPlayer ){ return S_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::RemovePlayerFromGroup"
HRESULT CDirectVoiceClientEngine::RemovePlayerFromGroup( DVID dvidGroup, DVID dvidPlayer ){ return S_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::DoSessionLost"
void CDirectVoiceClientEngine::DoSessionLost( HRESULT hrDisconnectResult ){ if( GetCurrentState() == DVCSTATE_CONNECTED ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "#### SESSION LOST [hr=0x%x]", hrDisconnectResult ); m_fSessionLost = TRUE; DoSignalDisconnect( hrDisconnectResult ); } else if( GetCurrentState() == DVCSTATE_DISCONNECTING ) { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "#### Received session lost during disconnect, completing disconnect" ); DoSignalDisconnect( m_hrDisconnectResult ); } else { DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "#### Received session lost but not connected or disconnecting, ignoring" ); }}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::DoSignalDisconnect"
void CDirectVoiceClientEngine::DoSignalDisconnect( HRESULT hrDisconnectResult ){ DPFX(DPFPREP, DVF_DISCONNECT_PROCEDURE_DEBUG_LEVEL, "#### Disconnecting [hr=0x%x]", hrDisconnectResult ); m_hrDisconnectResult = hrDisconnectResult; SetEvent( m_hNotifyDisconnect );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_Reset"
void CDirectVoiceClientEngine::ClientStats_Reset(){ memset( &m_stats, 0x00, sizeof( ClientStatistics ) );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_Dump_Record"
void CDirectVoiceClientEngine::ClientStats_Dump_Record(){ if( m_dvSoundDeviceConfig.dwFlags & DVSOUNDCONFIG_HALFDUPLEX ) { DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Session was half duplex, no record stats available" ); return; }
char tmpBuffer[200];
DWORD dwRecRunLength = m_pStatsBlob->m_recStats.m_dwTimeStop - m_pStatsBlob->m_recStats.m_dwTimeStart;
if( dwRecRunLength == 0 ) dwRecRunLength = 1;
DWORD dwNumInternalRuns = m_pStatsBlob->m_recStats.m_dwNumWakeups;
if( dwNumInternalRuns == 0 ) dwNumInternalRuns = 1;
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Start Lag (ms) : %u", m_pStatsBlob->m_recStats.m_dwStartLag ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Record Run Length (ms) : %u", dwRecRunLength );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Speech Size (Uncomp.) : %u", m_pStatsBlob->m_recStats.m_dwUnCompressedSize ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Frames / Buffer : %u", m_pStatsBlob->m_recStats.m_dwFramesPerBuffer ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Time / Frame (ms) : %u", m_pStatsBlob->m_recStats.m_dwFrameTime ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Silence Timeout : %u", m_pStatsBlob->m_recStats.m_dwSilenceTimeout ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "# of wakeups : %u", m_pStatsBlob->m_recStats.m_dwNumWakeups ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Runs / Wakeup : Avg: %u [%u..%u]", m_pStatsBlob->m_recStats.m_dwRPWTotal / dwNumInternalRuns, m_pStatsBlob->m_recStats.m_dwRPWMin, m_pStatsBlob->m_recStats.m_dwRPWMax );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "# of messages : %u", m_pStatsBlob->m_recStats.m_dwNumMessages ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Sent Frames : %u", m_pStatsBlob->m_recStats.m_dwSentFrames ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Ignored Frames : %u", m_pStatsBlob->m_recStats.m_dwIgnoredFrames ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Message Length (frames): Avg: %u [%u..%u]", (m_pStatsBlob->m_recStats.m_dwNumMessages == 0) ? 0 : m_pStatsBlob->m_recStats.m_dwMLTotal / m_pStatsBlob->m_recStats.m_dwNumMessages, m_pStatsBlob->m_recStats.m_dwMLMin, m_pStatsBlob->m_recStats.m_dwMLMax );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Header Size (bytes) : Avg: %u [%u..%u]", (m_pStatsBlob->m_recStats.m_dwSentFrames == 0) ? 0 : m_pStatsBlob->m_recStats.m_dwHSTotal / m_pStatsBlob->m_recStats.m_dwSentFrames, m_pStatsBlob->m_recStats.m_dwHSMin, m_pStatsBlob->m_recStats.m_dwHSMax ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Speech Size (bytes) : Avg: %u [%u..%u]", (m_pStatsBlob->m_recStats.m_dwSentFrames == 0) ? 0 : m_pStatsBlob->m_recStats.m_dwCSTotal / m_pStatsBlob->m_recStats.m_dwSentFrames, m_pStatsBlob->m_recStats.m_dwCSMin, m_pStatsBlob->m_recStats.m_dwCSMax );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Speech Convert (ms) : Avg: %u [%u..%u]", (m_pStatsBlob->m_recStats.m_dwSentFrames == 0) ? 0 : (m_pStatsBlob->m_recStats.m_dwCTTotal / m_pStatsBlob->m_recStats.m_dwSentFrames), m_pStatsBlob->m_recStats.m_dwCTMin, m_pStatsBlob->m_recStats.m_dwCTMax ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Record Resets : %u [Before Success %u..%u]", m_pStatsBlob->m_recStats.m_dwRRTotal, m_pStatsBlob->m_recStats.m_dwRRMin, m_pStatsBlob->m_recStats.m_dwRRMax ); sprintf( tmpBuffer, "Rec Movement (ms) : Avg: %u [%u..%u]", m_pStatsBlob->m_recStats.m_dwRMMSTotal / dwNumInternalRuns, m_pStatsBlob->m_recStats.m_dwRMMSMin, m_pStatsBlob->m_recStats.m_dwRMMSMax );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
sprintf( tmpBuffer, "Rec Movement (frames) : Avg: %.2f [%.2f..%.2f]", ( ((float)m_pStatsBlob->m_recStats.m_dwRMMSTotal) / ((float) dwNumInternalRuns)) / ((float) m_pStatsBlob->m_recStats.m_dwFrameTime), ((float) m_pStatsBlob->m_recStats.m_dwRMMSMin) / ((float) m_pStatsBlob->m_recStats.m_dwFrameTime), ((float) m_pStatsBlob->m_recStats.m_dwRMMSMax) / ((float) m_pStatsBlob->m_recStats.m_dwFrameTime));
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
sprintf( tmpBuffer, "Rec Movement (bytes) : Avg: %u [%u..%u]", m_pStatsBlob->m_recStats.m_dwRMBTotal / dwNumInternalRuns, m_pStatsBlob->m_recStats.m_dwRMBMin, m_pStatsBlob->m_recStats.m_dwRMBMax );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
sprintf( tmpBuffer, "Rec Movement (frames) : Avg: %.2f [%.2f..%.2f]", (((float) m_pStatsBlob->m_recStats.m_dwRMBTotal) / ((float) dwNumInternalRuns)) / ((float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize), ((float) m_pStatsBlob->m_recStats.m_dwRMBMin) / ((float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize), ((float) m_pStatsBlob->m_recStats.m_dwRMBMax) / ((float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize) );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer ); sprintf( tmpBuffer, "Move Delta (ms) : Avg: %u [%u..%u]", m_pStatsBlob->m_recStats.m_dwRTSLMTotal / dwNumInternalRuns, m_pStatsBlob->m_recStats.m_dwRTSLMMin, m_pStatsBlob->m_recStats.m_dwRTSLMMax );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
sprintf( tmpBuffer, "Move Delta (frames) : Avg: %.2f [%.2f..%.2f]", (((float) m_pStatsBlob->m_recStats.m_dwRTSLMTotal) / ((float) dwNumInternalRuns)) / ((float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize), ((float) m_pStatsBlob->m_recStats.m_dwRTSLMMin) / ((float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize), ((float) m_pStatsBlob->m_recStats.m_dwRTSLMMax) / ((float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize) );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer ); sprintf( tmpBuffer, "Record Lag (bytes) : Avg: %u [%u..%u]", m_pStatsBlob->m_recStats.m_dwRLTotal / dwNumInternalRuns, m_pStatsBlob->m_recStats.m_dwRLMin , m_pStatsBlob->m_recStats.m_dwRLMax );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
sprintf( tmpBuffer, "Record Lag (frames) : Avg: %.2f [%.2f..%.2f]", (float) ((float) m_pStatsBlob->m_recStats.m_dwRLTotal / (float) dwNumInternalRuns) / ((float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize), (float) ((float) m_pStatsBlob->m_recStats.m_dwRLMin) / (float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize, (float) ((float) m_pStatsBlob->m_recStats.m_dwRLMax) / (float) m_pStatsBlob->m_recStats.m_dwUnCompressedSize );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, tmpBuffer );
}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_Dump_Playback"
void CDirectVoiceClientEngine::ClientStats_Dump_Playback(){ DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Playback Stats: " );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Frames (silent) : %d", m_pStatsBlob->m_dwPPDQSilent ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Frames (lost) : %d", m_pStatsBlob->m_dwPPDQLost ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Frames (speech) : %d", m_pStatsBlob->m_dwPPDQSpeech );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Speech Decompress (ms) : Avg: %u [%u..%u]", (m_pStatsBlob->m_dwPPDQSpeech == 0) ? 0 : (m_pStatsBlob->m_dwPDTTotal / m_pStatsBlob->m_dwPPDQSpeech), m_pStatsBlob->m_dwPDTMin, m_pStatsBlob->m_dwPDTMax );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_Dump_Receive"
void CDirectVoiceClientEngine::ClientStats_Dump_Receive(){ DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Receive Stats: " );
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Received Frames : %d", m_pStatsBlob->m_dwPRESpeech ); DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "Received But Lost : %d", m_pStatsBlob->m_dwPRESpeech - m_pStatsBlob->m_dwPPDQSpeech );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_Dump_Transmit"
void CDirectVoiceClientEngine::ClientStats_Dump_Transmit(){}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_Dump"
void CDirectVoiceClientEngine::ClientStats_Dump(){ DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "STATS DUMP: ----------------------------------------------------[Begin] " ); ClientStats_Dump_Record(); ClientStats_Dump_Playback(); ClientStats_Dump_Receive(); ClientStats_Dump_Transmit();
DPFX(DPFPREP, DVF_STATS_DEBUG_LEVEL, "STATS DUMP: ------------------------------------------------------[End] " ); }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_Begin"
void CDirectVoiceClientEngine::ClientStats_Begin(){ m_pStatsBlob->m_dwTimeStart = GetTickCount(); m_pStatsBlob->m_dwMaxBuffers = 1; m_pStatsBlob->m_dwTotalBuffers = 1; m_pStatsBlob->m_dwPDTMin = 0xFFFFFFFF;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientStats_End"
void CDirectVoiceClientEngine::ClientStats_End(){ m_pStatsBlob->m_dwTimeStop = GetTickCount();}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientBufferAlloc"
PVOID CDirectVoiceClientEngine::ClientBufferAlloc( void *const pv, const DWORD dwSize ){ return new BYTE[dwSize];}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ClientBufferFree"
void CDirectVoiceClientEngine::ClientBufferFree( void *const pv, void *const pvBuffer ){ delete pvBuffer;}
#undef DPF_MODNAME
/*#define DPF_MODNAME "CDirectVoiceClientEngine::GetTransmitBuffer"
PDVTRANSPORT_BUFFERDESC CDirectVoiceClientEngine::GetTransmitBuffer( DWORD dwSize, LPVOID *ppvSendContext ){ PDVTRANSPORT_BUFFERDESC pNewBuffer;
pNewBuffer = new DVTRANSPORT_BUFFERDESC; pNewBuffer->pBufferData = new BYTE[dwSize]; pNewBuffer->dwBufferSize = dwSize; pNewBuffer->lRefCount = 0; pNewBuffer->dwObjectType = DVTRANSPORT_OBJECTTYPE_CLIENT; pNewBuffer->dwFlags = 0;
*ppvSendContext = pNewBuffer;
return pNewBuffer;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ReturnTransmitBuffer"
// ReturnTransmitBuffer
//
// PDVTRANSPORT_BUFFERDESC pBufferDesc - Buffer description of buffer to return
// LPVOID lpvContext - Context value to be used when returning the buffer
//
void CDirectVoiceClientEngine::ReturnTransmitBuffer( PVOID pvContext ){ PDVTRANSPORT_BUFFERDESC pBufferDesc = (PDVTRANSPORT_BUFFERDESC) pvContext; delete [] pBufferDesc->pBufferData; delete pBufferDesc; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SendComplete"
HRESULT CDirectVoiceClientEngine::SendComplete( PDVEVENTMSG_SENDCOMPLETE pSendComplete ){ ReturnTransmitBuffer( pSendComplete->pvUserContext ); return DV_OK;}*/
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::GetTransmitBuffer"
PDVTRANSPORT_BUFFERDESC CDirectVoiceClientEngine::GetTransmitBuffer( DWORD dwSize, LPVOID *ppvSendContext ){ PDVTRANSPORT_BUFFERDESC pNewBuffer = NULL; DWORD dwFPMIndex = 0xFFFFFFFF; DWORD dwWastedSpace = 0xFFFFFFFF; DWORD dwSearchFPMIndex = 0;
DNEnterCriticalSection( &m_csTransmitBufferLock );
pNewBuffer = (PDVTRANSPORT_BUFFERDESC) m_BufferDescPool.Get( );
DNLeaveCriticalSection( &m_csTransmitBufferLock );
DPFX(DPFPREP, DVF_BUFFERDESC_DEBUG_LEVEL, "BUFFERDESC: Got a buffer desc address 0x%p", (void *) pNewBuffer );
if( pNewBuffer == NULL ) { DPFX(DPFPREP, DVF_ERRORLEVEL, "Error getting transmit buffer" ); goto GETTRANSMITBUFFER_ERROR; }
pNewBuffer->lRefCount = 0; pNewBuffer->dwObjectType = DVTRANSPORT_OBJECTTYPE_CLIENT; pNewBuffer->dwFlags = 0; pNewBuffer->pBufferData = NULL;
for( dwSearchFPMIndex = 0; dwSearchFPMIndex < m_dwNumPools; dwSearchFPMIndex++ ) { // Potential pool
if( m_pdwBufferPoolSizes[dwSearchFPMIndex] >= dwSize ) { if( m_pdwBufferPoolSizes[dwSearchFPMIndex] - dwSize < dwWastedSpace ) { dwWastedSpace = m_pdwBufferPoolSizes[dwSearchFPMIndex] - dwSize; dwFPMIndex = dwSearchFPMIndex; } } }
if( dwFPMIndex == 0xFFFFFFFF ) { DNASSERT( FALSE ); DPFX(DPFPREP, 0, "Could not find pool large enough for buffer" ); goto GETTRANSMITBUFFER_ERROR; } pNewBuffer->pvContext = &m_pBufferPools[dwFPMIndex];
DNEnterCriticalSection( &m_csTransmitBufferLock ); pNewBuffer->pBufferData = (PBYTE) m_pBufferPools[dwFPMIndex].Get(); DNLeaveCriticalSection( &m_csTransmitBufferLock );
DPFX(DPFPREP, DVF_BUFFERDESC_DEBUG_LEVEL, "BUFFERDESC: Got a buffer value at address 0x%p", (void *) pNewBuffer->pBufferData );
DPFX(DPFPREP, DVF_BUFFERDESC_DEBUG_LEVEL, "BUFFERDESC: nInUse = %i", m_BufferDescPool.GetInUseCount() );
if( pNewBuffer->pBufferData == NULL ) { DPFX(DPFPREP, 0, "Error getting buffer for buffer desc" ); goto GETTRANSMITBUFFER_ERROR; } pNewBuffer->dwBufferSize = dwSize;
*ppvSendContext = pNewBuffer;
return pNewBuffer;
GETTRANSMITBUFFER_ERROR:
DNEnterCriticalSection( &m_csTransmitBufferLock ); if( pNewBuffer != NULL && pNewBuffer->pBufferData != NULL ) { ((CFixedPool*) pNewBuffer->pvContext)->Release( pNewBuffer->pBufferData ); }
if( pNewBuffer != NULL ) { m_BufferDescPool.Release( pNewBuffer ); } DNLeaveCriticalSection( &m_csTransmitBufferLock );
return NULL; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ReturnTransmitBuffer"
// ReturnTransmitBuffer
//
// PDVTRANSPORT_BUFFERDESC pBufferDesc - Buffer description of buffer to return
// LPVOID lpvContext - Context value to be used when returning the buffer
//
void CDirectVoiceClientEngine::ReturnTransmitBuffer( PVOID pvContext ){ PDVTRANSPORT_BUFFERDESC pBufferDesc = (PDVTRANSPORT_BUFFERDESC) pvContext; CFixedPool* pPool = (CFixedPool*) pBufferDesc->pvContext;
DPFX(DPFPREP, DVF_BUFFERDESC_DEBUG_LEVEL, "BUFFERDESC: Returning a buffer desc at address 0x%p", (void *) pBufferDesc ); DPFX(DPFPREP, DVF_BUFFERDESC_DEBUG_LEVEL, "BUFFERDESC: Returning a buffer at address 0x%p", (void *) pBufferDesc->pBufferData );
DNEnterCriticalSection( &m_csTransmitBufferLock );
// Release memory
pPool->Release( pBufferDesc->pBufferData );
// Release buffer description
m_BufferDescPool.Release( pvContext ); DPFX(DPFPREP, DVF_BUFFERDESC_DEBUG_LEVEL, "BUFFERDESC: nInUse = %i", m_BufferDescPool.GetInUseCount() );
DNLeaveCriticalSection( &m_csTransmitBufferLock );}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SendComplete"
HRESULT CDirectVoiceClientEngine::SendComplete( PDVEVENTMSG_SENDCOMPLETE pSendComplete ){ ReturnTransmitBuffer( pSendComplete->pvUserContext ); return DV_OK;}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::SetupInitialBuffers"
// SetupBuffersInitial
//
// This function sets up the first transmit buffers which do not vary
// in size w/the compression type.
//
HRESULT CDirectVoiceClientEngine::SetupInitialBuffers(){ HRESULT hr = DV_OK; DWORD dwIndex;
m_dwNumPools = CLIENT_POOLS_NUM;
if (!m_BufferDescPool.Initialize( sizeof(DVTRANSPORT_BUFFERDESC), NULL, NULL, NULL, NULL )) { DPFX(DPFPREP, 0, "Error allocating memory" ); hr = DVERR_OUTOFMEMORY; goto SETUPBUFFERS_ERROR; }
m_pBufferPools = new CFixedPool[m_dwNumPools];
if( m_pBufferPools == NULL ) { DPFX(DPFPREP, 0, "Error allocating memory" ); hr = DVERR_OUTOFMEMORY; goto SETUPBUFFERS_ERROR; }
m_pdwBufferPoolSizes = new DWORD[m_dwNumPools];
if( m_pdwBufferPoolSizes == NULL ) { DPFX(DPFPREP, 0, "Error allocating memory" ); hr = DVERR_OUTOFMEMORY; goto SETUPBUFFERS_ERROR; }
//This is broken if the number of client pools is ever adjusted from default
//value of 3. Since that's an unlikely change just compile time assert for now
DBG_CASSERT(CLIENT_POOLS_NUM==3); m_pdwBufferPoolSizes[0] = CLIENT_POOLS_SIZE_MESSAGE; m_pdwBufferPoolSizes[1] = CLIENT_POOLS_SIZE_PLAYERLIST; m_pdwBufferPoolSizes[ m_dwNumPools-1] = 0;
for( dwIndex = 0; dwIndex < m_dwNumPools-1; dwIndex++ ) { if (!m_pBufferPools[dwIndex].Initialize( m_pdwBufferPoolSizes[dwIndex], NULL, NULL, NULL, NULL )) { DPFX(DPFPREP, 0, "Error creating transmit buffers" ); hr=DVERR_OUTOFMEMORY; goto SETUPBUFFERS_ERROR; } }
return DV_OK;
SETUPBUFFERS_ERROR:
FreeBuffers();
return hr; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::SetupSpeechBuffer"
// SetupSpeechBuffer
//
// This function sets up the buffer pool for speech sends, whose size will
// depend on the compression type. Must be done after we know CT but
// before we do first speech transmission.
//
HRESULT CDirectVoiceClientEngine::SetupSpeechBuffer(){ if( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_PEER || m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_ECHO ) { m_pdwBufferPoolSizes[m_dwNumPools-1] = sizeof( DVPROTOCOLMSG_SPEECHHEADER )+m_dwCompressedFrameSize+COMPRESSION_SLUSH; } else { m_pdwBufferPoolSizes[m_dwNumPools-1] = sizeof( DVPROTOCOLMSG_SPEECHWITHTARGET ) + m_dwCompressedFrameSize + (sizeof( DVID )*CLIENT_POOLS_NUM_TARGETS_BUFFERED)+COMPRESSION_SLUSH; }
if (!m_pBufferPools[m_dwNumPools-1].Initialize( m_pdwBufferPoolSizes[m_dwNumPools-1], NULL, NULL, NULL, NULL )) { DPFX(DPFPREP, 0, "Error creating transmit buffers" ); return DVERR_OUTOFMEMORY; }
return DV_OK;} #undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceServerEngine::FreeBuffers"
HRESULT CDirectVoiceClientEngine::FreeBuffers(){ DWORD dwIndex;
if( m_pBufferPools != NULL ) { for( dwIndex = 0; dwIndex < m_dwNumPools; dwIndex++ ) { if (m_pdwBufferPoolSizes[dwIndex]) m_pBufferPools[dwIndex].DeInitialize( ); } delete [] m_pBufferPools;
m_pBufferPools = NULL; }
if( m_pdwBufferPoolSizes != NULL ) { delete [] m_pdwBufferPoolSizes; m_pdwBufferPoolSizes = 0; }
m_BufferDescPool.DeInitialize( );
m_dwNumPools = 0;
return DV_OK; }
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ValidateSessionType"
BOOL CDirectVoiceClientEngine::ValidateSessionType( DWORD dwSessionType ){ return (dwSessionType > 0 && dwSessionType < DVSESSIONTYPE_MAX);}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ValidateSessionFlags"
BOOL CDirectVoiceClientEngine::ValidateSessionFlags( DWORD dwFlags ){ return (dwFlags < DVSESSION_MAX);}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ValidatePlayerFlags"
// Only allow player flags that specify either a 0 or the half duplex flags
BOOL CDirectVoiceClientEngine::ValidatePlayerFlags(DWORD dwFlags){ return (dwFlags == DVPLAYERCAPS_HALFDUPLEX || dwFlags == 0);}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ValidatePlayerDVID"
BOOL CDirectVoiceClientEngine::ValidatePlayerDVID(DVID dvid){ return (dvid != DVID_ALLPLAYERS);}
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::ValidatePacketType"
BOOL CDirectVoiceClientEngine::ValidatePacketType( const DVPROTOCOLMSG_FULLMESSAGE* lpdvFullMessage ) const{
switch( lpdvFullMessage->dvGeneric.dwType ) { case DVMSGID_HOSTMIGRATELEAVE: case DVMSGID_HOSTMIGRATED: case DVMSGID_CREATEVOICEPLAYER: case DVMSGID_DELETEVOICEPLAYER: case DVMSGID_PLAYERLIST: return ( ( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_PEER ) ); break; case DVMSGID_SPEECHWITHFROM: return ( ( m_dvSessionDesc.dwSessionType == DVSESSIONTYPE_FORWARDING) ); break; case DVMSGID_SETTARGETS: return ( m_dvSessionDesc.dwFlags & DVSESSION_SERVERCONTROLTARGET ); break; }
return TRUE;}
|
