windows-xp/Source/XPSP1/NT/multimedia/directx/dplay/dvoice/dxvoice/dvcleng.cpp

/*==========================================================================
 *
 *  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.
 *
 ***************************************************************************/

#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 windows timer used by this 
// class each time the timer goes off.  The function signals
// a semaphore provided by the creator of the timer. 
//
// Parameters:
// DWORD param - A recast pointer to a HANDLE
#undef DPF_MODNAME
#define DPF_MODNAME "CDirectVoiceClientEngine::MixingWakeupProc"
BOOL CDirectVoiceClientEngine::MixingWakeupProc( DWORD_PTR param )
{
    TimerHandlerParam *pParam = (TimerHandlerParam *) param;

    SetEvent( pParam->hPlaybackTimerEvent );
    SetEvent( pParam->hRecordTimerEvent );

    DNEnterCriticalSection( &pParam->csPlayCount );
    pParam->lPlaybackCount++;
    DNLeaveCriticalSection( &pParam->csPlayCount );

    return TRUE;
}


#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_pfpNotifications(NULL),
		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_dvSoundDeviceConfig.lpdsCaptureDevice = NULL;
	m_dvSoundDeviceConfig.lpdsPlaybackDevice = NULL;	

	memset( &m_dvCaps, 0x00, sizeof( DVCAPS ) );
	m_dvCaps.dwSize = sizeof( DVCAPS );
	m_dvCaps.dwFlags = 0;

	ClientStats_Reset();

	ZeroMemory( &m_perfInfo, sizeof( PERF_APPLICATION ) );
	ZeroMemory( &m_perfAppInfo, sizeof( PERF_APPLICATION_INFO ) );

}

#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;
	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;
	InitBilink( &m_blPlayActivePlayers, NULL );
	InitBilink( &m_blPlayAddPlayers, NULL );
	InitBilink( &m_blNotifyActivePlayers, NULL );
	InitBilink( &m_blNotifyAddPlayers, NULL );

	ZeroMemory( &m_perfInfo, sizeof( PERF_APPLICATION_INFO ) );

	// Setup for performance entry
	// TODO: Get the GUID of the instance for the session
	m_perfInfo.dwFlags = PERF_APPLICATION_VALID | PERF_APPLICATION_VOICE;
	CoCreateGuid( &m_perfInfo.guidApplicationInstance );
	CoCreateGuid( &m_perfInfo.guidInternalInstance );
	m_perfInfo.guidIID = IID_IDirectPlayVoiceClient;
	m_perfInfo.dwProcessID = GetCurrentProcessId();
	m_perfInfo.dwMemoryBlockSize = sizeof( ClientStatistics ) + sizeof( DVSESSIONDESC );

	// Initilalize the new performance library
	hr = PERF_AddEntry( &m_perfInfo, &m_perfAppInfo );

	// This is an error, but not fatal
	if( FAILED ( hr ) )
	{
		DPFX(DPFPREP,  DVF_ERRORLEVEL, "Unable to create performance tracking object 0x%x", hr );
	}

	if( m_perfAppInfo.pbMemoryBlock )
	{
		m_pStatsBlob = (ClientStatistics *) m_perfAppInfo.pbMemoryBlock;
	}
	else
	{
		m_pStatsBlob = &m_stats;
	}

	m_fpPlayers.Initialize();
	
    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();

	PERF_RemoveEntry( m_perfInfo.guidInternalInstance, &m_perfAppInfo );
	
    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;

	// 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;		
	}	

	// 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 = m_fpPlayers.Get();

	if( pNewPlayer == NULL )
	{
		DPFX(DPFPREP,  DVF_ERRORLEVEL, "Unable to allocate new player for client/server" );
		return DVERR_OUTOFMEMORY;
	}

	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 Timer;

	if( m_pTimer == NULL )
	{
		SetConnectResult( DVERR_OUTOFMEMORY );

		goto EXIT_ERROR;
	}

    if( !m_pTimer->Create( m_lpdvfCompressionInfo->dwTimeout / DV_CLIENT_WAKEUP_MULTIPLER, 0, (DWORD_PTR) &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( lpdvConnectAccept->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;


	// 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;
	}

	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( !HandleCreateVoicePlayer( 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;
	
	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
//
// Performs initialization required to create the specified user's record.
//
// 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::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;
	}

	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 )
	{
		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 = m_fpPlayers.Get();

		if( newPlayer == NULL )
		{
			DPFX(DPFPREP,  DVF_ERRORLEVEL, "Unable to allocate new player record.  Alloc failure" );
			return TRUE;
		}

		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;
	}

	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;
	}	

	// 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 )
	{

		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 )
	{
		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 )
	{
		// 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;
	}

	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;

	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;
		HandleCreateVoicePlayer( lpdvSpeech->dvidFrom, &dvPlayerJoin, sizeof( DVPROTOCOLMSG_PLAYERJOIN ) );
	}
	else
	{
		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 )
	{
		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();	

	// Remove us from the list of apps running
	PERF_RemoveEntry( m_perfInfo.guidInternalInstance, &m_perfAppInfo );
	m_pStatsBlob = NULL;

	ZeroMemory( &m_perfInfo, sizeof( PERF_APPLICATION ) );
	ZeroMemory( &m_perfAppInfo, sizeof( PERF_APPLICATION_INFO ) );

	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()
{
	if( m_pBufferDescPool == NULL )
		return;

	while( 1 ) 
	{
		DNEnterCriticalSection( &m_pBufferDescPool->cs );

		if( m_pBufferDescPool->nInUse == 0 )
		{
			DNLeaveCriticalSection( &m_pBufferDescPool->cs );			
			break;
		}

		DNLeaveCriticalSection( &m_pBufferDescPool->cs );

		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;
		
	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;
	}
	
	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 )
{
	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;
	LPBYTE lpSessionBuffer = 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();


	CVoicePlayer *pVoicePlayer;

	/*hr = m_voiceNameTable.GetEntry( dvID, &pVoicePlayer, FALSE );

	if( FAILED( hr ) )
	{
		DPFX(DPFPREP,  5, "Ignoring duplicate removeplayer hr=0x%x", hr );
		return DV_OK;
	}*/

	DVPROTOCOLMSG_PLAYERQUIT dvPlayerQuit;

	dvPlayerQuit.dwType = DVMSGID_DELETEVOICEPLAYER;
	dvPlayerQuit.dvidID = dvID;

	HandleDeleteVoicePlayer( 0, &dvPlayerQuit, sizeof( DVPROTOCOLMSG_PLAYERQUIT ) );		

	// 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(  )
{
	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 );

	CNotifyElement *neElement;
	
	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;
		BILINK *pblSearch;
		DVMSG_PLAYEROUTPUTLEVEL dvPlayerLevel;

		pblSearch = m_blNotifyActivePlayers.next;

		while( pblSearch != &m_blNotifyActivePlayers )
		{
			pCurrentPlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList );

			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->next;
		}
	}	

	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" );

	BILINK *pblSearch;
	CVoicePlayer *pCurrentPlayer;
	DVPROTOCOLMSG_PLAYERQUIT msgPlayerQuit;

	pblSearch = m_blNotifyActivePlayers.next;

	msgPlayerQuit.dwType = DVMSGID_DELETEVOICEPLAYER;

	while( pblSearch != &m_blNotifyActivePlayers )
	{	
		pCurrentPlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList );

		if( dwCurTime - pCurrentPlayer->GetLastPlayback() > DV_MULTICAST_USERTIMEOUT_PERIOD )
		{
			msgPlayerQuit.dvidID = pCurrentPlayer->GetPlayerID();
			HandleDeleteVoicePlayer( pCurrentPlayer->GetPlayerID(), &msgPlayerQuit, sizeof( DVPROTOCOLMSG_PLAYERQUIT ) );
		}

		pblSearch = pblSearch->next;
	}

	DPFX(DPFPREP,   DVF_INFOLEVEL, "Done Enum" );

	return;
}

// Cleanup any outstanding entries on the playback lists
void CDirectVoiceClientEngine::CleanupPlaybackLists(  )
{
	BILINK *pblSearch;
	CVoicePlayer *pVoicePlayer;

	DNEnterCriticalSection( &m_csPlayAddList );

	m_dwPlayActiveCount = 0;

	pblSearch = m_blPlayActivePlayers.next;

	while( pblSearch != &m_blPlayActivePlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList );
		pVoicePlayer->RemoveFromPlayList();
		pVoicePlayer->Release();
		pblSearch = m_blPlayActivePlayers.next;
	}

	pblSearch = m_blPlayAddPlayers.next;

	while( pblSearch != &m_blPlayAddPlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList );
		pVoicePlayer->RemoveFromPlayList();
		pVoicePlayer->Release();
		pblSearch = m_blPlayAddPlayers.next;
	}

	DNLeaveCriticalSection( &m_csPlayAddList );
}

// Cleanup any outstanding entries on the playback lists
void CDirectVoiceClientEngine::CleanupNotifyLists(  )
{
	BILINK *pblSearch;
	CVoicePlayer *pVoicePlayer;

	DNEnterCriticalSection( &m_csNotifyAddList );

	pblSearch = m_blNotifyActivePlayers.next;

	while( pblSearch != &m_blNotifyActivePlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList );
		pVoicePlayer->RemoveFromNotifyList();
		pVoicePlayer->Release();
		pblSearch = m_blNotifyActivePlayers.next;
	}

	pblSearch = m_blNotifyAddPlayers.next;

	while( pblSearch != &m_blNotifyAddPlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList );
		pVoicePlayer->RemoveFromNotifyList();
		pVoicePlayer->Release();
		pblSearch = m_blNotifyAddPlayers.next;
	}

	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( )
{
	BILINK *pblSearch;
	CVoicePlayer *pVoicePlayer;

	DNEnterCriticalSection( &m_csPlayAddList );

	// Add players who are pending
	pblSearch = m_blPlayAddPlayers.next;

	while( pblSearch != &m_blPlayAddPlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList );

		pVoicePlayer->RemoveFromPlayList();
		pVoicePlayer->AddToPlayList( &m_blPlayActivePlayers );
		m_dwPlayActiveCount++;

		pblSearch = m_blPlayAddPlayers.next;
	}

	DNLeaveCriticalSection( &m_csPlayAddList );

	// Remove players who have disconnected
	pblSearch = m_blPlayActivePlayers.next;

	while( pblSearch != &m_blPlayActivePlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList );

		pblSearch = pblSearch->next;

		// 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( )
{
	BILINK *pblSearch;
	CVoicePlayer *pVoicePlayer;

	DNEnterCriticalSection( &m_csNotifyAddList );

	// Add players who are pending
	pblSearch = m_blNotifyAddPlayers.next;

	while( pblSearch != &m_blNotifyAddPlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList );

		pVoicePlayer->RemoveFromNotifyList();
		pVoicePlayer->AddToNotifyList( &m_blNotifyActivePlayers );

		pblSearch = m_blNotifyAddPlayers.next;
	}

	DNLeaveCriticalSection( &m_csNotifyAddList );

	// Remove players who have disconnected
	pblSearch = m_blNotifyActivePlayers.next;

	while( pblSearch != &m_blNotifyActivePlayers )
	{
		pVoicePlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blNotifyList );

		pblSearch = pblSearch->next;

		// 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;
	Timer				*lpTimer = NULL;
    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;
	BILINK				*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.next;

				while( pblSearch != &This->m_blPlayActivePlayers )
				{
					pCurrentPlayer = CONTAINING_RECORD( pblSearch, CVoicePlayer, m_blPlayList );

					pblSearch = pblSearch->next;

					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( FAILED( hr ) )
					{
						DPFX(DPFPREP,  DVF_ERRORLEVEL, "Unable to get frame from player hr=0x%x", hr );
						This->HandleThreadError( DVERR_GENERIC );
						goto EXIT_PLAYBACK;
					}

					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:

	if( lpTimer != NULL )
	{
	    delete lpTimer;
	}

    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_pfpNotifications->Get( m_pfpNotifications );

	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 )
	{
	    PDVMSG_PLAYERVOICESTOP pMsgStop = (PDVMSG_PLAYERVOICESTOP) lpData;

	    DNASSERT( pMsgStop->dwSize == sizeof( DVMSG_PLAYERVOICESTOP ) );
	    DNASSERT( dwDataSize == sizeof( DVMSG_PLAYERVOICESTOP ) );	    
	}

	if( dwMessageType == DVMSGID_PLAYERVOICESTART )
	{
	    PDVMSG_PLAYERVOICESTART pMsgStart = (PDVMSG_PLAYERVOICESTART) lpData;

	    DNASSERT( pMsgStart->dwSize == sizeof( DVMSG_PLAYERVOICESTART ) );
	    DNASSERT( dwDataSize == sizeof( DVMSG_PLAYERVOICESTART ) );	    
	}

	if( dwMessageType == DVMSGID_PLAYEROUTPUTLEVEL )
	{
	    PDVMSG_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_pfpNotifications->Release( m_pfpNotifications, 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();

    m_pfpNotifications = FPM_Create( sizeof( CNotifyElement ), NULL, NULL, NULL, NULL, NULL, NULL );
    
    if (m_pfpNotifications==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_pfpNotifications->Release( m_pfpNotifications, 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_pfpNotifications != NULL )
	{
		m_pfpNotifications->Fini(m_pfpNotifications);
		m_pfpNotifications = NULL;
	}

    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_pBufferDescPool->Get( m_pBufferDescPool );

    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(m_pBufferPools[dwFPMIndex]);
    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_pBufferDescPool->nInUse );	

    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 )
    {
        ((PFPOOL) pNewBuffer->pvContext)->Release( ((PFPOOL) pNewBuffer->pvContext), pNewBuffer->pBufferData );
    }

    if( pNewBuffer != NULL )
    {
        m_pBufferDescPool->Release( m_pBufferDescPool, 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;
    PFPOOL pPool = (PFPOOL) 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( pPool, pBufferDesc->pBufferData );

    // Release buffer description
    m_pBufferDescPool->Release( m_pBufferDescPool, pvContext );
	DPFX(DPFPREP,  DVF_BUFFERDESC_DEBUG_LEVEL, "BUFFERDESC: nInUse  = %i", m_pBufferDescPool->nInUse );

    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;

    m_pBufferDescPool = FPM_Create( sizeof(DVTRANSPORT_BUFFERDESC), NULL, NULL, NULL, NULL, &m_pStatsBlob->m_dwBDPOutstanding, &m_pStatsBlob->m_dwBDPAllocated );

    if( m_pBufferDescPool == NULL )
    {
        DPFX(DPFPREP,  0, "Error allocating memory" );
        hr = DVERR_OUTOFMEMORY;
        goto SETUPBUFFERS_ERROR;
    }

    m_pBufferPools = new PFPOOL[m_dwNumPools];

    if( m_pBufferPools == NULL )
    {
        DPFX(DPFPREP,  0, "Error allocating memory" );
        hr = DVERR_OUTOFMEMORY;
        goto SETUPBUFFERS_ERROR;
    }

    memset( m_pBufferPools, 0x00, sizeof( PFPOOL ) * m_dwNumPools );

    m_pdwBufferPoolSizes = new DWORD[m_dwNumPools];

    if( m_pdwBufferPoolSizes == NULL )
    {
        DPFX(DPFPREP,  0, "Error allocating memory" );
        hr = DVERR_OUTOFMEMORY;
        goto SETUPBUFFERS_ERROR;
    }

    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++ )
    {
        m_pBufferPools[dwIndex] = FPM_Create( m_pdwBufferPoolSizes[dwIndex], NULL, NULL, NULL, NULL, &m_pStatsBlob->m_dwBPOutstanding[dwIndex], &m_pStatsBlob->m_dwBPAllocated[dwIndex] );

        if( m_pBufferPools == NULL )
        {
            DPFX(DPFPREP,  0, "Error creating transmit buffers" );
            goto SETUPBUFFERS_ERROR;
        }
    }

    m_pBufferPools[dwIndex] = NULL;

    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;
    }

    m_pBufferPools[m_dwNumPools-1] = FPM_Create( m_pdwBufferPoolSizes[m_dwNumPools-1], NULL, NULL, NULL, NULL, &m_pStatsBlob->m_dwBPOutstanding[m_dwNumPools-1], &m_pStatsBlob->m_dwBPAllocated[m_dwNumPools-1] );

    if( m_pBufferPools == 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_pBufferPools[dwIndex] != NULL )
                m_pBufferPools[dwIndex]->Fini(m_pBufferPools[dwIndex],FALSE);
        }
        
        delete [] m_pBufferPools;

        m_pBufferPools = NULL;
    }

    if( m_pdwBufferPoolSizes != NULL )
    {
        delete [] m_pdwBufferPoolSizes;
        m_pdwBufferPoolSizes = 0;
    }

    if( m_pBufferDescPool != NULL )
    {
        m_pBufferDescPool->Fini( m_pBufferDescPool, FALSE );
        m_pBufferDescPool = NULL;
    }

    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"
BOOL CDirectVoiceClientEngine::ValidatePlayerFlags(DWORD dwFlags)
{
	return (dwFlags < DVPLAYERCAPS_MAX);
}

#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( PDVPROTOCOLMSG_FULLMESSAGE lpdvFullMessage )
{

	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;
}