doom3-bfg/neo/sys/sys_voicechat.cpp

/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  

Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#pragma hdrstop
#include "../idlib/precompiled.h"
#include "sys_voicechat.h"

/*
================================================
idVoiceChatMgr::Init
================================================
*/
void idVoiceChatMgr::Init( void * pXAudio2 ) {
}

/*
================================================
idVoiceChatMgr::Shutdown
================================================
*/
void idVoiceChatMgr::Shutdown() {

	// We shouldn't have voice users if everything shutdown correctly
	assert( talkers.Num() == 0 );
	assert( remoteMachines.Num() == 0 );
}

/*
================================================
idVoiceChatMgr::RegisterTalker
================================================
*/
void idVoiceChatMgr::RegisterTalker( lobbyUser_t * user, int lobbyType, bool isLocal ) {
	
	int i = FindTalkerIndex( user, lobbyType );
	
	if ( !verify( i == -1 ) ) {
		assert( talkers[i].lobbyType == lobbyType );
		idLib::Printf( "RegisterTalker: Talker already registered.\n" );
		return;
	}
	
	// Talker not found, need to create a new one
	
	talker_t newTalker; 

	newTalker.user				= user;
	newTalker.isLocal			= isLocal;
	newTalker.lobbyType			= lobbyType;
	newTalker.registered		= false;
	newTalker.registeredSuccess	= false;
	newTalker.machineIndex		= -1;
	newTalker.groupIndex		= 0;		// 0 is default group

	if ( !newTalker.IsLocal() ) {		// If this is a remote talker, register his machine address
		newTalker.machineIndex = AddMachine( user->address, lobbyType );
	}

	talkers.Append( newTalker );
	
	// Since we added a new talker, make sure he is registered. UpdateRegisteredTalkers will catch all users, including this one.
	UpdateRegisteredTalkers();
}

/*
================================================
idVoiceChatMgr::UnregisterTalker
================================================
*/
void idVoiceChatMgr::UnregisterTalker( lobbyUser_t * user, int lobbyType, bool isLocal ) {
	int i = FindTalkerIndex( user, lobbyType );
	
	if ( !verify( i != -1 ) ) {
		idLib::Printf( "UnregisterTalker: Talker not found.\n" );
		return;
	}
	
	talker_t & talker = talkers[i];
	
	assert( talker.IsLocal() == ( talker.machineIndex == -1 ) );
	assert( talker.IsLocal() == isLocal );

	talker.lobbyType = -1;		// Mark for removal
	UpdateRegisteredTalkers();		// Make sure the user gets unregistered before we remove him/her

	if ( talker.machineIndex != -1 ) {
		// Unregister the talkers machine (unique address) handle
		RemoveMachine( talker.machineIndex, lobbyType );
	}

	talkers.RemoveIndex( i );	// Finally, remove the talker
}

/*
================================================
idVoiceChatMgr::GetActiveLocalTalkers
================================================
*/
void idVoiceChatMgr::GetActiveLocalTalkers( idStaticList< int, MAX_PLAYERS > & localTalkers ) {
	
	localTalkers.Clear();

	for ( int i = 0; i < talkers.Num(); i++ ) {
		
		if ( !talkers[i].IsLocal() ) {
			continue;
		}

		if ( !talkers[i].registeredSuccess ) {
			continue;
		}

		if ( !TalkerHasData( i ) ) {
			continue;
		}
		
		localTalkers.Append( i );
	}
}

/*
================================================
idVoiceChatMgr::GetRecipientsForTalker
================================================
*/
void idVoiceChatMgr::GetRecipientsForTalker( int talkerIndex, idStaticList< const lobbyAddress_t *, MAX_PLAYERS > & recipients ) {
	
	recipients.Clear();
	
	talker_t & talker = talkers[talkerIndex];
	
	if ( !talker.IsLocal() ) {
		return;
	}
	
	sendFrame++;
	
	for ( int i = 0; i < talkers.Num(); i++ ) {
		if ( !talkers[i].registeredSuccess ) {
			continue;
		}

		if ( talkers[i].IsLocal() ) {
			continue;		// Only want to send to remote talkers
		}

		if ( !CanSendVoiceTo( talkerIndex, i ) ) {
			continue;
		}

		if ( !sendGlobal && talkers[i].groupIndex != activeGroupIndex ) {
			continue;
		}

		assert( talkers[i].machineIndex >= 0 );

		remoteMachine_t & remoteMachine = remoteMachines[ talkers[i].machineIndex ];

		assert( remoteMachine.refCount > 0 );
		assert( remoteMachine.lobbyType == activeLobbyType );

		if ( remoteMachine.sendFrame == sendFrame ) {
			continue;		// Already on the recipient list
		}

		remoteMachine.sendFrame = sendFrame;

		recipients.Append( &remoteMachine.address );
	}
}

/*
================================================
idVoiceChatMgr::SetTalkerGroup
================================================
*/
void idVoiceChatMgr::SetTalkerGroup( const lobbyUser_t * user, int lobbyType, int groupIndex ) {
	int i = FindTalkerIndex( user, lobbyType );
	
	if ( !verify( i != -1 ) ) {
		idLib::Printf( "SetTalkerGroup: Talker not found.\n" );
		return;
	}
	
	// Assign the new group index to this talker
	talkers[i].groupIndex = groupIndex;
	
	// Since the group index of this player changed, call UpdateRegisteredTalkers, which will register the 
	// appropriate users based on the current active group and session
	UpdateRegisteredTalkers();
}

/*
================================================
idVoiceChatMgr::SetActiveLobby
================================================
*/
void idVoiceChatMgr::SetActiveLobby( int lobbyType ) {
	if ( activeLobbyType != lobbyType ) {
		activeLobbyType = lobbyType;
		// When the active session changes, we need to immediately call UpdateRegisteredTalkers, 
		// which will make sure the appropriate talkers are registered depending on the activeSession.
		UpdateRegisteredTalkers();
	}
}

/*
================================================
idVoiceChatMgr::SetActiveChatGroup
================================================
*/
void idVoiceChatMgr::SetActiveChatGroup( int groupIndex ) {
	if ( activeGroupIndex != groupIndex ) {
		activeGroupIndex = groupIndex;
		// When the active group changes, we need to immediately call UpdateRegisteredTalkers, 
		// which will make sure the appropriate talkers are registered depending on the activeGroup.
		UpdateRegisteredTalkers();
	}
}

/*
================================================
idVoiceChatMgr::FindTalkerByUserId
================================================
*/
int idVoiceChatMgr::FindTalkerByUserId( lobbyUserID_t userID, int lobbyType ) {
	for ( int i = 0; i < talkers.Num(); i++ ) {
		if ( talkers[i].user->lobbyUserID == userID && talkers[i].lobbyType == lobbyType ) {
			return i;
		}
	}
	
	return -1;			// Not found
}

/*
================================================
idVoiceChatMgr::GetLocalChatData
================================================
*/
bool idVoiceChatMgr::GetLocalChatData( int talkerIndex, byte * data, int & dataSize ) {
	talker_t & talker = talkers[talkerIndex];

	if ( !talker.IsLocal() ) {
		idLib::Printf( "GetLocalChatData: Talker not local.\n" );
		return false;	// Talker is remote
	}
	
	if ( !talker.registeredSuccess ) {
		return false;
	}

	idBitMsg voiceMsg;
	voiceMsg.InitWrite( data, dataSize );

	talker.user->lobbyUserID.WriteToMsg( voiceMsg );
	voiceMsg.WriteByteAlign();

	// Remove the size of the userid field from the available buffer size
	int voiceDataSize = dataSize - voiceMsg.GetSize();

	if ( !GetLocalChatDataInternal( talkerIndex, voiceMsg.GetWriteData() + voiceMsg.GetSize(), voiceDataSize ) ) {
		dataSize = 0;
		return false;
	}

	dataSize = voiceDataSize + voiceMsg.GetSize();

	// Mark the user as talking
	talker.talking		= true;
	talker.talkingTime	= Sys_Milliseconds();

	return dataSize > 0 ? true : false;
}

/*
================================================
idVoiceChatMgr::SubmitIncomingChatData
================================================
*/
void idVoiceChatMgr::SubmitIncomingChatData( const byte * data, int dataSize ) {		
	lobbyUserID_t lobbyUserID;
	
	idBitMsg voiceMsg;
	voiceMsg.InitRead( data, dataSize );

	lobbyUserID.ReadFromMsg( voiceMsg );
	voiceMsg.ReadByteAlign();
	
	int i = FindTalkerByUserId( lobbyUserID, activeLobbyType );
	
	if ( i == -1 ) {
		idLib::Printf( "SubmitIncomingChatData: Talker not found in session.\n" );
		return;	// Talker is not in this session
	}

	talker_t & talker = talkers[i];

	if ( talker.registeredSuccess && !talker.isMuted ) {
		// Mark the user as talking
		talker.talking		= true;
		talker.talkingTime	= Sys_Milliseconds();

		SubmitIncomingChatDataInternal( i, voiceMsg.GetReadData() + voiceMsg.GetReadCount(), voiceMsg.GetRemainingData() );
	}
}

/*
========================
idVoiceChatMgr::GetVoiceState
========================
*/
voiceState_t idVoiceChatMgr::GetVoiceState( const lobbyUser_t * user ) {
	int i = FindTalkerByUserId( user->lobbyUserID, activeLobbyType );
	
	if ( i == -1 ) {
		return VOICECHAT_STATE_NO_MIC;
	}

	talker_t & talker = talkers[i];

	if ( !talker.hasHeadset ) {
		return VOICECHAT_STATE_NO_MIC;
	}

	if ( talker.isMuted ) {
		return VOICECHAT_STATE_MUTED_LOCAL;
	}

	if ( talker.talking && Sys_Milliseconds() - talker.talkingTime > 200 ) {
		talker.talking = false;
	}

	return talker.talking ? (talker.talkingGlobal ? VOICECHAT_STATE_TALKING_GLOBAL : VOICECHAT_STATE_TALKING ) : VOICECHAT_STATE_NOT_TALKING;
}

/*
========================
idVoiceChatMgr::CanSendVoiceTo
========================
*/
bool idVoiceChatMgr::CanSendVoiceTo( int talkerFromIndex, int talkerToIndex ) { 
	talker_t & talkerFrom = talkers[talkerFromIndex];

	if ( !talkerFrom.IsLocal() ) {
		return false;
	}

	talker_t & talkerTo = talkers[talkerToIndex];

	if ( talkerTo.isMuted ) {
		return false;
	}

	return true;
}

/*
========================
idVoiceChatMgr::IsRestrictedByPrivleges
========================
*/
bool idVoiceChatMgr::IsRestrictedByPrivleges() {
	return ( disableVoiceReasons & REASON_PRIVILEGES ) != 0;
}

/*
========================
idVoiceChatMgr::ToggleMuteLocal
========================
*/
void idVoiceChatMgr::ToggleMuteLocal( const lobbyUser_t * src, const lobbyUser_t * target ) {
	int fromTalkerIndex = FindTalkerByUserId( src->lobbyUserID, activeLobbyType );
	
	if ( fromTalkerIndex == -1 ) {
		return;
	}

	int toTalkerIndex = FindTalkerByUserId( target->lobbyUserID, activeLobbyType );
	
	if ( toTalkerIndex == -1 ) {
		return;
	}

	talker_t & targetTalker = talkers[toTalkerIndex];

	targetTalker.isMuted = targetTalker.isMuted ? false : true;
}

//================================================
//			**** INTERNAL **********
//================================================

/*
================================================
idVoiceChatMgr::FindTalkerIndex
================================================
*/
int idVoiceChatMgr::FindTalkerIndex( const lobbyUser_t * user, int lobbyType ) {
	for ( int i = 0; i < talkers.Num(); i++ ) {
		if ( talkers[i].user == user && talkers[i].lobbyType == lobbyType ) {
			return i;
		}
	}
	
	return -1;			// Not found
}

/*
================================================
idVoiceChatMgr::FindMachine
================================================
*/
int idVoiceChatMgr::FindMachine( const lobbyAddress_t & address, int lobbyType ) {	
	for ( int i = 0; i < remoteMachines.Num(); i++ ) {
		if ( remoteMachines[i].refCount == 0 ) {
			continue;
		}
		if ( remoteMachines[i].lobbyType == lobbyType && remoteMachines[i].address.Compare( address ) ) {
			return i;
		}
	}
	return -1;	// Not found
}

/*
================================================
idVoiceChatMgr::AddMachine
================================================
*/
int idVoiceChatMgr::AddMachine( const lobbyAddress_t & address, int lobbyType ) {
		
	int machineIndex = FindMachine( address, lobbyType );
	
	if ( machineIndex != -1 ) {
		// If we find an existing machine, just increase the ref
		remoteMachines[machineIndex].refCount++;
		return machineIndex;
	}

	//
	// We didn't find a machine, we'll need to add one
	//

	// First, see if there is a free machine slot to take
	int index = -1;

	for ( int i = 0; i < remoteMachines.Num(); i++ ) {
		if ( remoteMachines[i].refCount == 0 ) {
			index = i;
			break;
		}
	}

	remoteMachine_t newMachine;

	newMachine.lobbyType	= lobbyType;
	newMachine.address		= address;
	newMachine.refCount		= 1;
	newMachine.sendFrame	= -1;

	if ( index == -1 ) {
		// If we didn't find a machine slot, then add one
		index = remoteMachines.Append( newMachine );
	} else {
		// Re-use the machine slot we found
		remoteMachines[index] = newMachine;
	}
	
	return index;
}

/*
================================================
idVoiceChatMgr::RemoveMachine
================================================
*/
void idVoiceChatMgr::RemoveMachine( int machineIndex, int lobbyType ) {
	
	assert( remoteMachines[machineIndex].refCount > 0 );
	assert( remoteMachines[machineIndex].lobbyType == lobbyType );
	
	// Don't remove the machine.  refCount will eventually reach 0, which will free up the slot to reclaim.
	// We don't want to remove it, because that would invalidate users machineIndex handles into the array
	remoteMachines[machineIndex].refCount--;
}

/*
================================================
idVoiceChatMgr::UpdateRegisteredTalkers
================================================
*/
void idVoiceChatMgr::UpdateRegisteredTalkers() {	
	for ( int pass = 0; pass < 2; pass++ ) {
		for ( int i = 0; i < talkers.Num(); i++ ) {
			talker_t & talker = talkers[i];
		
			bool shouldBeRegistered = ( talker.lobbyType != -1 && disableVoiceReasons == 0 && talker.lobbyType == activeLobbyType );

			if ( shouldBeRegistered && pass == 0 ) {
				continue;		// Only unregister on first pass to make room for when the second pass will possibly register new talkers
			}
		
			if ( talker.registered != shouldBeRegistered ) {
				if ( !talker.registered ) {
					talker.registeredSuccess = RegisterTalkerInternal( i );
				} else if ( talker.registeredSuccess ) {
					UnregisterTalkerInternal( i );
					talker.registeredSuccess = false;
				}
			
				talker.registered = shouldBeRegistered;
			}
		}
	}
}

/*
================================================
idVoiceChatMgr::SetDisableVoiceReason
================================================
*/
void idVoiceChatMgr::SetDisableVoiceReason( disableVoiceReason_t reason ) {	
	if ( ( disableVoiceReasons & reason ) == 0 ) {
		disableVoiceReasons |= reason;
		UpdateRegisteredTalkers();
	}
}

/*
================================================
idVoiceChatMgr::ClearDisableVoiceReason
================================================
*/
void idVoiceChatMgr::ClearDisableVoiceReason( disableVoiceReason_t reason ) {	
	if ( ( disableVoiceReasons & reason ) != 0 ) {
		disableVoiceReasons &= ~reason;
		UpdateRegisteredTalkers();
	}
}

/*
================================================
idVoiceChatMgr::SetHeadsetState
================================================
*/
void idVoiceChatMgr::SetHeadsetState( int talkerIndex, bool state ) {
	talker_t & talker = talkers[ talkerIndex ];

	talker.hasHeadset = state;
}

/*
================================================
idVoiceChatMgr::HasHeadsetStateChanged
================================================
*/
bool idVoiceChatMgr::HasHeadsetStateChanged( int talkerIndex )
{
	talker_t & talker = talkers[ talkerIndex ];
	
	// We should only be checking this on the local user
	assert( talker.IsLocal() );
	
	bool ret = talker.hasHeadsetChanged;
	talker.hasHeadsetChanged = false;

	return ret;
}