windows-server-2003/multimedia/directx/dplay/dvoice/dxvtlib/loopback.cpp

/*==========================================================================
 *
 *  Copyright (C) 1999 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:		loopback.cpp
 *  Content:	Implements the loopback portion of the full duplex test
 *
 *  History:
 *   Date		By		Reason
 *   ====		==		======
 * 09/10/99		pnewson	Created
 * 10/25/99		rodtoll	Removed lpszVoicePassword member from sessiondesc
 * 10/27/99		pnewson 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
 *  11/04/99	pnewson Bug #115279 changed SendMessage to PostMessage to resolve some deadlocks
 *  11/30/99	pnewson	use default codec
 *						use devices passed to CheckAudioSetup, instead of default devices
 *  12/01/99	rodtoll	Added flag to cause wizard to auto-select the microphone
 *  01/14/2000	rodtoll	Updated with API changes  
 *  01/21/2000	pnewson	Updated for UI revisions
 *						Updated to support use of loopback tests for full duplex testing
 *  01/27/2000	rodtoll	Updated with API changes
 *  02/08/2000	rodtoll	Bug #131496 - Selecting DVTHRESHOLD_DEFAULT results in voice
 *						never being detected 
 *  03/03/2000	rodtoll	Updated to handle alternative gamevoice build.   
 *  04/19/2000	pnewson	    Error handling cleanup  
 * 04/21/2000  rodtoll   Bug #32952 Does not run on Win95 GOLD w/o IE4 installed
 * 06/21/2000	rodtoll	Updated to use new parameters
 * 06/28/2000	rodtoll	Prefix Bug #38022
 *  07/31/2000	rodtoll	Bug #39590 - SB16 class soundcards are passing when they should fail
 *						Half duplex code was being ignored in mic test portion. 
 *  08/28/2000	masonb  Voice Merge: Changed ccomutil.h to ccomutil.h
 * 08/31/2000 	rodtoll	Bug #43804 - DVOICE: dwSensitivity structure member is confusing - should be dwThreshold 
 *  11/29/2000	rodtoll	Bug #48348 - DPVOICE: Modify wizard to make use of DirectPlay8 as the transport. 
 *						NOTE: Now requires a TCP/IP adapter to be present (or at least loopback)
 * 02/04/2001	simonpow	Bug #354859 PREfast spotted errors (PostMessage return codes incorrectly
 *							treated as HRESULTs)
 * 04/12/2001	kareemc	WINBUG #360971 - Wizard Memory Leaks
 * 02/28/2002	rodtoll	PREFAST was reporting issue w/lines 350 and 351.  Fixed.
 * 
 ***************************************************************************/

#include "dxvtlibpch.h"


#undef DPF_SUBCOMP
#define DPF_SUBCOMP DN_SUBCOMP_VOICE


// application defined message ids
//#define WMAPP_LOOPBACKRUNNING 	WM_USER + 1
//#define WMAPP_INPUTVOLUME		WM_USER + 2

// {53CA3FB7-4FD5-4a67-99E4-6F2496E6FEC2}
static const GUID GUID_LOOPBACKTEST = 
	{ 0x53ca3fb7, 0x4fd5, 0x4a67, { 0x99, 0xe4, 0x6f, 0x24, 0x96, 0xe6, 0xfe, 0xc2 } };

HRESULT StartDirectPlay( PDIRECTPLAY8SERVER* lplpdp8 );
HRESULT StopDirectPlay( PDIRECTPLAY8SERVER lpdp8 );

#undef DPF_MODNAME
#define DPF_MODNAME "DVMessageHandlerServer"
HRESULT PASCAL DVMessageHandlerServer( 
	LPVOID 		lpvUserContext,
	DWORD 		dwMessageType,
	LPVOID  	lpMessage
)
{
	DPF_ENTER();
	switch( dwMessageType )
	{
	case DVMSGID_CREATEVOICEPLAYER:
		break;
	case DVMSGID_DELETEVOICEPLAYER:
		break;
	case DVMSGID_SESSIONLOST:
		break;
	case DVMSGID_PLAYERVOICESTART:
		break;
	case DVMSGID_PLAYERVOICESTOP:
		break;
	case DVMSGID_RECORDSTART:
		break;
	case DVMSGID_RECORDSTOP:
		break;
	case DVMSGID_CONNECTRESULT:
		break;		
	case DVMSGID_DISCONNECTRESULT:
		break;
	case DVMSGID_INPUTLEVEL:
		break;
	case DVMSGID_OUTPUTLEVEL:
		break;
	default:
		break;
	}

	DPF_EXIT();
	return DV_OK;
}

#undef DPF_MODNAME
#define DPF_MODNAME "DVMessageHandlerClient"
HRESULT PASCAL DVMessageHandlerClient( 
	LPVOID 		lpvUserContext,
	DWORD 		dwMessageType,
	LPVOID    	lpMessage
)
{
	DPF_EXIT();

	HWND hwndDialog;
	HWND hwndPeakMeter;
	HWND hwndSlider;
	LONG lRet;
	HRESULT hr;
	CSupervisorInfo* lpsinfo;
	PDVMSG_INPUTLEVEL pdvInputLevel;
	PDVMSG_OUTPUTLEVEL pdvOutputLevel;

	lpsinfo = (CSupervisorInfo*)lpvUserContext;

	if( lpsinfo )
	{
		if( !lpsinfo->GetLoopbackRunning() )
			return DV_OK;
	}

	
	switch( dwMessageType )
	{
	case DVMSGID_CREATEVOICEPLAYER:
		break;
	case DVMSGID_DELETEVOICEPLAYER:
		break;
	case DVMSGID_SESSIONLOST:
		break;
	case DVMSGID_PLAYERVOICESTART:
		break;
	case DVMSGID_PLAYERVOICESTOP:
		break;
	case DVMSGID_RECORDSTART:
		if (lpsinfo == NULL)
		{
			break;
		}

		// forward the message along to the appropriate window
		lpsinfo->GetHWNDDialog(&hwndDialog);
		if (!PostMessage(hwndDialog, WM_APP_RECORDSTART, 0, 0))
		{
			DPFX(DPFPREP, DVF_ERRORLEVEL, "PostMessage failed, code: %i", GetLastError());
			break;	// no error return, just continue
		}
		break;
		
	case DVMSGID_RECORDSTOP:
		if (lpsinfo == NULL)
		{
			break;
		}
		
		// forward the message along to the appropriate window
		lpsinfo->GetHWNDDialog(&hwndDialog);
		if (!PostMessage(hwndDialog, WM_APP_RECORDSTOP, 0, 0))
		{
			DPFX(DPFPREP, DVF_ERRORLEVEL, "PostMessage failed, code: %i", GetLastError());
			break;	// no error return, just continue
		}
		break;
		
	case DVMSGID_CONNECTRESULT:
		break;		
	case DVMSGID_DISCONNECTRESULT:
		break;
	case DVMSGID_INPUTLEVEL:
		if (lpsinfo == NULL)
		{
			break;
		}
		// update the peak meter
		lpsinfo->GetHWNDInputPeak(&hwndPeakMeter);
		if (IsWindow(hwndPeakMeter))
		{
			pdvInputLevel = (PDVMSG_INPUTLEVEL) lpMessage;
			if (!PostMessage(hwndPeakMeter, PM_SETCUR, 0, pdvInputLevel->dwPeakLevel ))
			{
				DPFX(DPFPREP, DVF_ERRORLEVEL, "PostMessage failed, code: %i", GetLastError());
				break;	// no error return, just continue
			}
		}

		// update the volume slider
		lpsinfo->GetHWNDInputVolumeSlider(&hwndSlider);
		if (IsWindow(hwndSlider))
		{
			pdvInputLevel = (PDVMSG_INPUTLEVEL) lpMessage;
			if (!PostMessage(hwndSlider, TBM_SETPOS, 1, DBToAmpFactor(DSBVOLUME_MAX)-DBToAmpFactor(pdvInputLevel->lRecordVolume)))
			{
				DPFX(DPFPREP, DVF_ERRORLEVEL, "PostMessage failed, code: %i", GetLastError());
				break;	// no error return, just continue
			}
		}
		
		break;
		
	case DVMSGID_OUTPUTLEVEL:
		if (lpsinfo == NULL)
		{
			break;
		}
		// update the peak meter
		lpsinfo->GetHWNDOutputPeak(&hwndPeakMeter);
		if (IsWindow(hwndPeakMeter))
		{
			pdvOutputLevel = (PDVMSG_OUTPUTLEVEL) lpMessage;
			if (!PostMessage(hwndPeakMeter, PM_SETCUR, 0, pdvOutputLevel->dwPeakLevel ))
			{
				DPFX(DPFPREP, DVF_ERRORLEVEL, "PostMessage failed, code: %i", GetLastError());
				break;	// no error return, just continue
			}
		}

		// update the volume slider
		lpsinfo->GetHWNDOutputVolumeSlider(&hwndSlider);
		if (IsWindow(hwndSlider))
		{
			DWORD dwVolume = 0;	// Set to 0 to avoid PREFIX bug

			// Get the current waveOut volume and set the slider to that position
			hr = lpsinfo->GetWaveOutVolume(&dwVolume);
			if (FAILED(hr))
			{
				// couldn't get the volume - set the slider to top
				PostMessage(hwndSlider, TBM_SETPOS, 1, DBToAmpFactor(DSBVOLUME_MAX) - DBToAmpFactor(DSBVOLUME_MAX));
				// disable the slider
				PostMessage(hwndSlider, WM_CANCELMODE, 0, 0 );
			}
			else
			{
				PostMessage(hwndSlider, TBM_SETPOS, 1, (DBToAmpFactor(DSBVOLUME_MAX) - DBToAmpFactor(DSBVOLUME_MIN)) - dwVolume);
			}
		}
		
		break;

	default:
		break;
	}

	DPF_EXIT();
	return DV_OK;
}

#undef DPF_MODNAME
#define DPF_MODNAME "StartDirectPlay"
HRESULT StartDirectPlay( PDIRECTPLAY8SERVER* lplpdp8 )
{
	HRESULT hr = DPN_OK;
	LONG lRet = S_OK;
    PDIRECTPLAY8ADDRESS pDeviceAddress = NULL;
    DPN_APPLICATION_DESC dpnApplicationDesc;

	DPF_ENTER();

	*lplpdp8 = NULL;
	
    hr = COM_CoCreateInstance(
    	CLSID_DirectPlay8Server, 
    	NULL, 
    	CLSCTX_INPROC_SERVER, 
    	IID_IDirectPlay8Server, 
    	(void **)lplpdp8, FALSE);
    if (FAILED(hr))
    {
    	*lplpdp8 = NULL;
    	DPFX(DPFPREP, DVF_ERRORLEVEL, "CoCreateInstance for DirectPlay failed, code: %i", hr);
    	goto error_cleanup;
    }

    hr = COM_CoCreateInstance( 
        CLSID_DirectPlay8Address, 
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_IDirectPlay8Address,
        (void **)&pDeviceAddress, FALSE );

    if( FAILED( hr ) )
    {
        pDeviceAddress = NULL;
        DPFX(DPFPREP, DVF_ERRORLEVEL, "CoCreateInstance for DirectPlay8Address failed, code: 0x%x", hr );
        goto error_cleanup;
    }

	// 
	// NOTE: This now causes the wizard to require TCP/IP to be installed.
	// (doesn't have to be dialed up -- as long as local loopback is available)
	//
	// Eventually build a loopback SP for directplay8.
	//
	// TODO: Allow this to fall back to other SPs or use loopback SP
	//
    hr = pDeviceAddress->SetSP( &CLSID_DP8SP_TCPIP );

    if( FAILED( hr ) )
    {
        DPFX(DPFPREP,  DVF_ERRORLEVEL, "Failed setting SP for address, code: 0x%x", hr );
        goto error_cleanup;
    }

    hr = (*lplpdp8)->Initialize( NULL, DVMessageHandlerServer, 0 );

    if( FAILED( hr ) )
    {
        DPFX(DPFPREP,  DVF_ERRORLEVEL, "Failed initializing directplay layer, code: 0x%x", hr );
        goto error_cleanup;
    }

    ZeroMemory( &dpnApplicationDesc, sizeof( DPN_APPLICATION_DESC ) );
    dpnApplicationDesc.dwSize = sizeof( DPN_APPLICATION_DESC );
    dpnApplicationDesc.guidApplication = GUID_LOOPBACKTEST;
    dpnApplicationDesc.dwFlags = DPNSESSION_NODPNSVR | DPNSESSION_CLIENT_SERVER;

    hr = (*lplpdp8)->Host( 
                        &dpnApplicationDesc, 
                        &pDeviceAddress, 
                        1, 
                        NULL,
                        NULL,
                        NULL, 
                        0 );

    if( FAILED( hr ) )
    {
        DPFX(DPFPREP,  DVF_ERRORLEVEL, "Failed to host on directplay layer, code: 0x%x", hr );
        goto error_cleanup;
    }

    pDeviceAddress->Release();

	DPF_EXIT();
	return S_OK;

error_cleanup:
	if (*lplpdp8 != NULL)
	{
	    (*lplpdp8)->Close(0);
	    (*lplpdp8)->Release();
		*lplpdp8 = NULL;
	}

	if( pDeviceAddress )
	{
		pDeviceAddress->Release();
	}

	DPF_EXIT();
	return hr;
}

#undef DPF_MODNAME
#define DPF_MODNAME "StopDirectPlay"
HRESULT StopDirectPlay(PDIRECTPLAY8SERVER lpdp8)
{

	DPF_ENTER();

	// Kill the session
	if (lpdp8 != NULL)
	{
        lpdp8->Close(0);

        lpdp8->Release();
	}

	
	DPF_EXIT();
	return S_OK;

}

#undef DPF_MODNAME
#define DPF_MODNAME "StartLoopback"
HRESULT StartLoopback(
	LPDIRECTPLAYVOICESERVER* lplpdvs, 
	LPDIRECTPLAYVOICECLIENT* lplpdvc,
	PDIRECTPLAY8SERVER* lplpdp8, 
	LPVOID lpvCallbackContext,
	HWND hwndAppWindow,
	const GUID& guidCaptureDevice,
	const GUID& guidRenderDevice,
	DWORD dwFlags)
{
	HRESULT hr;
	DWORD dwSize = 0;
	DVCLIENTCONFIG dvcc;
	DVSOUNDDEVICECONFIG dvsdc;
	DVID dvidAllPlayers = DVID_ALLPLAYERS;	
	PBYTE pDeviceConfigBuffer = NULL;
	PDVSOUNDDEVICECONFIG pdvsdc = NULL;
	BOOL fVoiceSessionStarted = FALSE;
	BOOL fClientConnected = FALSE;

	DPF_ENTER();

	*lplpdvs = NULL;
	*lplpdvc = NULL;

	hr = COM_CoCreateInstance(
		CLSID_DirectPlayVoice, 
		NULL, 
		CLSCTX_INPROC_SERVER, 
		IID_IDirectPlayVoiceServer, 
		(void **)lplpdvs, FALSE);
	if (FAILED(hr))
	{
		*lplpdvs = NULL;
		DPFX(DPFPREP, DVF_ERRORLEVEL, "CoCreateInstance failed, code: %i", hr);
		goto error_cleanup;
	}

	hr = (*lplpdvs)->Initialize(*lplpdp8, DVMessageHandlerServer, lpvCallbackContext, NULL, 0);
	if (FAILED(hr))
	{
		DPFX(DPFPREP, DVF_ERRORLEVEL, "IDirectPlayVoiceServer::Initialize failed, code: %i", hr);
		goto error_cleanup;
	}

	DVSESSIONDESC dvSessionDesc;

	dvSessionDesc.dwSize = sizeof( DVSESSIONDESC );
	dvSessionDesc.dwBufferAggressiveness = DVBUFFERAGGRESSIVENESS_DEFAULT;
	dvSessionDesc.dwBufferQuality = DVBUFFERQUALITY_DEFAULT;
	dvSessionDesc.dwFlags = 0;
	dvSessionDesc.dwSessionType = DVSESSIONTYPE_ECHO;
	// Note this compression type is used for its short frame size so
	// we can quickly detect lockups.
    dvSessionDesc.guidCT = DPVCTGUID_NONE;     

	hr = (*lplpdvs)->StartSession( &dvSessionDesc, 0 );
	if (FAILED(hr))
	{
		DPFX(DPFPREP, DVF_ERRORLEVEL, "IDirectPlayVoiceServer::StartSession failed, code: %i", hr);
		goto error_cleanup;
	}
	fVoiceSessionStarted = TRUE;
	
	hr = COM_CoCreateInstance(
		CLSID_DirectPlayVoice, 
		NULL, 
		CLSCTX_INPROC_SERVER, 
		IID_IDirectPlayVoiceClient, 
		(void **)lplpdvc, FALSE);
	if (FAILED(hr))
	{
		*lplpdvc = NULL;
		DPFX(DPFPREP, DVF_ERRORLEVEL, "CoCreateInstance failed, code: %i", hr);
		goto error_cleanup;
	}

	hr = (*lplpdvc)->Initialize(*lplpdp8, DVMessageHandlerClient, lpvCallbackContext, NULL, 0);
	if (FAILED(hr))
	{
		DPFX(DPFPREP, DVF_ERRORLEVEL, "IDirectPlayVoiceClient::Initialize failed, code: %i", hr);
		goto error_cleanup;
	}

	dvsdc.dwSize = sizeof( DVSOUNDDEVICECONFIG );
	dvsdc.hwndAppWindow = hwndAppWindow;
	dvsdc.dwFlags = DVSOUNDCONFIG_AUTOSELECT;
	if (dwFlags & DVSOUNDCONFIG_HALFDUPLEX)
	{
		// The caller wants a half duplex session.
		dvsdc.dwFlags |= DVSOUNDCONFIG_HALFDUPLEX;
	}
	if (dwFlags & DVSOUNDCONFIG_TESTMODE)
	{
		// The caller wants a test mode session.
		dvsdc.dwFlags |= DVSOUNDCONFIG_TESTMODE;
	}
	dvsdc.guidCaptureDevice = guidCaptureDevice;
	dvsdc.guidPlaybackDevice = guidRenderDevice;
	dvsdc.lpdsPlaybackDevice = NULL;
	dvsdc.lpdsCaptureDevice = NULL;
	dvsdc.dwMainBufferFlags = 0;
	dvsdc.dwMainBufferPriority = 0;
	dvsdc.lpdsMainBuffer = NULL;

	dvcc.dwSize = sizeof( DVCLIENTCONFIG );
	dvcc.dwFlags = 
		DVCLIENTCONFIG_AUTOVOICEACTIVATED | 
		DVCLIENTCONFIG_AUTORECORDVOLUME | DVCLIENTCONFIG_AUTOVOLUMERESET |
		DVCLIENTCONFIG_PLAYBACKMUTE;  // we don't want the user to hear his/her voice right away
	dvcc.dwThreshold = DVTHRESHOLD_UNUSED;
	dvcc.lPlaybackVolume = DSBVOLUME_MAX;
	dvcc.lRecordVolume = DSBVOLUME_MAX;
	dvcc.dwNotifyPeriod = 50;
	dvcc.dwBufferQuality = DVBUFFERQUALITY_DEFAULT;
	dvcc.dwBufferAggressiveness = DVBUFFERAGGRESSIVENESS_DEFAULT;

	hr = (*lplpdvc)->Connect( &dvsdc, &dvcc, DVFLAGS_SYNC|DVFLAGS_NOQUERY );
	if (FAILED(hr))
	{
		DPFX(DPFPREP, DVF_ERRORLEVEL, "IDirectPlayVoiceClient::Connect failed, code: %i", hr);
		goto error_cleanup;
	}
	fClientConnected = TRUE;

	hr = (*lplpdvc)->SetTransmitTargets(&dvidAllPlayers, 1 , 0);
	if (FAILED(hr))
	{
		DPFX(DPFPREP, DVF_ERRORLEVEL, "IDirectPlayVoiceClient::SetTransmitTargets failed, code: %i", hr);
		goto error_cleanup;
	}
	
	dwSize = 0;
	hr = (*lplpdvc)->GetSoundDeviceConfig(pdvsdc, &dwSize);
	if( hr != DVERR_BUFFERTOOSMALL )
	{
		DPFX(DPFPREP,  DVF_ERRORLEVEL, "IDirectPlayVoiceClient::GetSoundDeviceConfig failed, hr: %i", hr);
		goto error_cleanup;
	}

	pDeviceConfigBuffer = new BYTE[dwSize];
	if( pDeviceConfigBuffer == NULL )
	{
		DPFX(DPFPREP,  DVF_ERRORLEVEL, "Memory alloc failure" );
		hr = DVERR_OUTOFMEMORY;
		goto error_cleanup;
	}

	pdvsdc = (PDVSOUNDDEVICECONFIG) pDeviceConfigBuffer;
	pdvsdc->dwSize = sizeof( DVSOUNDDEVICECONFIG );

	hr = (*lplpdvc)->GetSoundDeviceConfig(pdvsdc, &dwSize );
	if (FAILED(hr))
	{
		DPFX(DPFPREP,  DVF_ERRORLEVEL, "IDirectPlayVoiceClient::GetSoundDeviceConfig failed, hr: %i", hr);
		goto error_cleanup;
	}

	// If we're looking for full duplex fail and notify caller if we get half duplex
	if( !(dwFlags & DVSOUNDCONFIG_HALFDUPLEX) )
	{
		if (pdvsdc->dwFlags & DVSOUNDCONFIG_HALFDUPLEX)
		{
			DPFX(DPFPREP,  DVF_ERRORLEVEL, "We received a half duplex when we expected full duplex" );
			// It only started up in half duplex. Notify the caller.
			hr = DV_HALFDUPLEX;
			goto error_cleanup;
		}
	} 

	if( pdvsdc->dwFlags & DVSOUNDCONFIG_HALFDUPLEX )
	{
		DPFX(DPFPREP,  DVF_INFOLEVEL, "StartLoopBack() returning DV_HALFDUPLEX flags=0x%x dwFlags = 0x%x", pdvsdc->dwFlags, dwFlags );
		// it started in fullduplex, notify the caller
		delete [] pDeviceConfigBuffer;
		DPF_EXIT();
		return DV_HALFDUPLEX;
	}
	else
	{
		DPFX(DPFPREP,  DVF_INFOLEVEL, "StartLoopBack() returning DV_FULLDUPLEX flags=0x%x dwFlags = 0x%x", pdvsdc->dwFlags, dwFlags );		
		// it started in fullduplex, notify the caller
		delete [] pDeviceConfigBuffer;
		DPF_EXIT();
		return DV_FULLDUPLEX;
	}

error_cleanup:

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

	if (*lplpdvc != NULL)
	{
		if (fClientConnected)
		{
			(*lplpdvc)->Disconnect(DVFLAGS_SYNC);
			fClientConnected = FALSE;
		}
		(*lplpdvc)->Release();
		*lplpdvc = NULL;
	}

	if (*lplpdvs != NULL)
	{
		if (fVoiceSessionStarted)
		{
			(*lplpdvs)->StopSession(0);
			fVoiceSessionStarted = FALSE;
		}
		(*lplpdvs)->Release();
		*lplpdvs = NULL;
	}

	DPFX(DPFPREP,  DVF_ERRORLEVEL, "StartLoopback() returning hr=0x%x", hr );
	
	DPF_EXIT();
	return hr;
}

#undef DPF_MODNAME
#define DPF_MODNAME "StopLoopback"
HRESULT StopLoopback(
	LPDIRECTPLAYVOICESERVER lpdvs, 
	LPDIRECTPLAYVOICECLIENT lpdvc,
	PDIRECTPLAY8SERVER lpdp8 )
{
	HRESULT hr;
	LONG lRet;
	BOOL fRet;
	BOOL fClientConnected = TRUE;
	BOOL fVoiceSessionRunning = TRUE;
	
	DPF_ENTER();

	if (lpdvc != NULL)
	{
		hr = lpdvc->Disconnect(DVFLAGS_SYNC);
		fClientConnected = FALSE;
		if (FAILED(hr))
		{
			DPFX(DPFPREP, DVF_ERRORLEVEL, "IDirectPlayVoiceClient::Disconnect failed, hr: %i", hr);
			goto error_cleanup;
		}
		
		lpdvc->Release();
		lpdvc = NULL;
	}

	if (lpdvs != NULL)
	{
		hr = lpdvs->StopSession(0);
		fVoiceSessionRunning = FALSE;
		if (FAILED(hr))
		{
			DPFX(DPFPREP, DVF_ERRORLEVEL, "IDirectPlayVoiceServer::StopSession failed, hr: %i", hr);
			goto error_cleanup;
		}
		lpdvs->Release();
		lpdvs = NULL;
	}

	DPF_EXIT();
	return S_OK;

error_cleanup:
	if (lpdvc != NULL)
	{
		if (fClientConnected)
		{
			lpdvc->Disconnect(DVFLAGS_SYNC);
			fClientConnected = FALSE;
		}
		lpdvc->Release();
		lpdvc = NULL;
	}

	if (lpdvs != NULL)
	{
		if (fVoiceSessionRunning)
		{
			lpdvs->StopSession(0);
			fVoiceSessionRunning = FALSE;
		}
		lpdvs->Release();
		lpdvs = NULL;
	}

	DPF_EXIT();
	return hr;
}