feat: half-done ghost voicechat

Author: aIIison

src/Features/Demo/NetworkGhostPlayer.cpp

@@ -1,20 +1,21 @@
 #include "NetworkGhostPlayer.hpp"
 
 #include "DemoGhostPlayer.hpp"
-#include "GhostLeaderboard.hpp"
 #include "Event.hpp"
-#include "Scheduler.hpp"
 #include "Features/Hud/Toasts.hpp"
 #include "Features/NetMessage.hpp"
 #include "Features/Session.hpp"
 #include "Features/Speedrun/SpeedrunTimer.hpp"
 #include "GhostEntity.hpp"
+#include "GhostLeaderboard.hpp"
 #include "Modules/Client.hpp"
 #include "Modules/Console.hpp"
 #include "Modules/Engine.hpp"
+#include "Modules/Scheme.hpp"
 #include "Modules/Server.hpp"
+#include "Modules/SteamAPI.hpp"
 #include "Modules/Surface.hpp"
-#include "Modules/Scheme.hpp"
+#include "Scheduler.hpp"
 
 #include <chrono>
 #include <functional>
@@ -532,20 +533,54 @@ void NetworkManager::RunNetwork() {
 }
 
 void NetworkManager::SendPlayerData() {
-	sf::Packet packet;
-	packet << HEADER::UPDATE << this->ID;
-	auto player = client->GetPlayer(GET_SLOT() + 1);
-	if (player) {
-		bool grounded = player->ground_entity();
-		packet << DataGhost{client->GetAbsOrigin(player), engine->GetAngles(engine->IsOrange() ? 0 : GET_SLOT()), client->GetViewOffset(player).z, grounded};
-	} else {
-		packet << DataGhost::Invalid();
+	{
+		sf::Packet packet;
+		packet << HEADER::UPDATE << this->ID;
+		auto player = client->GetPlayer(GET_SLOT() + 1);
+		if (player) {
+			bool grounded = player->ground_entity();
+			packet << DataGhost{client->GetAbsOrigin(player), engine->GetAngles(engine->IsOrange() ? 0 : GET_SLOT()), client->GetViewOffset(player).z, grounded};
+		} else {
+			packet << DataGhost::Invalid();
+		}
+
+		if (!ghost_TCP_only.GetBool()) {
+			this->udpSocket.send(packet, this->serverIP, this->serverPort);
+		} else {
+			this->tcpSocket.send(packet);
+		}
 	}
 
-	if (!ghost_TCP_only.GetBool()) {
-		this->udpSocket.send(packet, this->serverIP, this->serverPort);
-	} else {
-		this->tcpSocket.send(packet);
+	// voice.
+	{
+		// read local microphone input.
+		uint32_t nBytesAvailable = 0;
+		EVoiceResult res = steam->SteamUser()->GetAvailableVoice(&nBytesAvailable, NULL, 0);
+
+		if (res == k_EVoiceResultOK && nBytesAvailable > 0) {
+			uint32_t nBytesWritten = 0;
+			MsgVoiceChatData_t msg;
+
+			// don't send more than 1 KB at a time.
+			uint8_t buffer[1024 + sizeof(msg)];
+
+			res = steam->SteamUser()->GetVoice(true, buffer + sizeof(msg), 1024, &nBytesWritten, false, NULL, 0, NULL, 0);
+
+			if (res == k_EVoiceResultOK && nBytesWritten > 0) {
+				msg.SetDataLength(nBytesWritten);
+				memcpy(buffer, &msg, sizeof(msg));
+
+				sf::Packet packet;
+				packet << HEADER::VOICE << this->ID;
+				packet.append(buffer, sizeof(msg) + nBytesWritten);
+
+				if (!ghost_TCP_only.GetBool()) {
+					this->udpSocket.send(packet, this->serverIP, this->serverPort);
+				} else {
+					this->tcpSocket.send(packet);
+				}
+			}
+		}
 	}
 }
 
@@ -705,6 +740,9 @@ void NetworkManager::ReceiveUDPUpdates(std::vector<sf::Packet> &buffer) {
 	} while (status == sf::Socket::Done);
 }
 
+uint8_t g_pbUncompressedVoice[11025 * 2];
+uint32_t g_numUncompressedBytes;
+
 void NetworkManager::Treat(sf::Packet &packet, bool udp) {
 	HEADER header;
 	sf::Uint32 ID;
@@ -999,6 +1037,27 @@ void NetworkManager::Treat(sf::Packet &packet, bool udp) {
 		}
 		break;
 	}
+	case HEADER::VOICE: {
+		console->Warning("voice packet.\n");
+
+		const auto pMessage = (uintptr_t)(packet.getData()) + 5;
+
+		const MsgVoiceChatData_t *pMsgVoiceData = (const MsgVoiceChatData_t *)pMessage;
+
+		uint8_t pbUncompressedVoice[11025 * 2];
+		uint32_t numUncompressedBytes = 0;
+		const uint8_t *pVoiceData = (const uint8_t *)pMessage;
+		pVoiceData += sizeof(MsgVoiceChatData_t);
+
+		EVoiceResult res = steam->SteamUser()->DecompressVoice(pVoiceData, pMsgVoiceData->GetDataLength(), pbUncompressedVoice, sizeof(pbUncompressedVoice), &numUncompressedBytes, 11025);
+
+		if (res == k_EVoiceResultOK && numUncompressedBytes > 0) {
+			memcpy(g_pbUncompressedVoice, pbUncompressedVoice, sizeof(pbUncompressedVoice));
+			g_numUncompressedBytes = numUncompressedBytes;
+		}
+
+		break;
+	}
 	default:
 		break;
 	}
@@ -1322,6 +1381,9 @@ ON_EVENT(FRAME) {
 	}
 }
 
+Command ghost_voice_on("+ghost_voice", +[](const CCommand &args) { steam->SteamUser()->StartVoiceRecording(); }, "+ghost_voice - push to talk in voice chat\n");
+Command ghost_voice_off("-ghost_voice", +[](const CCommand &args) { steam->SteamUser()->StopVoiceRecording(); }, "-ghost_voice - push to talk in voice chat\n");
+
 CON_COMMAND(ghost_chat, "ghost_chat - open the chat HUD for messaging other players\n") {
 	if (g_chatType == 0 && networkManager.isConnected) {
 		g_wasChatType = 0;

src/Features/Demo/NetworkGhostPlayer.hpp

@@ -30,6 +30,7 @@ enum class HEADER {
 	COLOR_CHANGE,
 	TAUNT,
 	LOCATOR,
+	VOICE,
 };
 
 class NetworkManager {
@@ -128,3 +129,5 @@ extern Command ghost_name;
 
 extern int g_chatType;
 extern int g_wasChatType;
+extern uint8_t g_pbUncompressedVoice[11025 * 2];
+extern uint32_t g_numUncompressedBytes;

src/Modules/Engine.cpp

@@ -934,6 +934,21 @@ int __stdcall BinkWait_Detour(void *bink) {
 	}
 }
 
+
+int Voice_GetOutputData_Detour(const int iChannel, char *copyBufBytes, const int copyBufSize, const int samplePosition, const int sampleCount);
+int (*Voice_GetOutputData)(const int iChannel, char *copyBufBytes, const int copyBufSize, const int samplePosition, const int sampleCount);
+static Hook Voice_GetOutputData_Hook(&Voice_GetOutputData_Detour);
+int Voice_GetOutputData_Detour(const int iChannel, char *copyBufBytes, const int copyBufSize, const int samplePosition, const int sampleCount) {
+	memcpy(copyBufBytes, g_pbUncompressedVoice, g_numUncompressedBytes);
+
+	return g_numUncompressedBytes;
+
+	// _Voice_GetOutputData_Hook.Disable();
+	// _Voice_GetOutputData();
+	// _Voice_GetOutputData_Hook.Enable();
+}
+
+
 Color Engine::GetLightAtPoint(Vector point) {
 #ifdef _WIN32
 	// MSVC bug workaround - COM interfaces apparently don't quite follow
@@ -1199,6 +1214,9 @@ bool Engine::Init() {
 		this->DestroyDebugMesh = this->g_physCollision->Original<_DestroyDebugMesh>(Offsets::DestroyDebugMesh);
 	}
 
+	Voice_GetOutputData = Memory::Scan<decltype(Voice_GetOutputData)>(this->Name(), "55 8B EC 51 8B 45 10 53 56");
+	Voice_GetOutputData_Hook.SetFunc(Voice_GetOutputData);
+
 #ifdef _WIN32
 	auto bink_mod = Memory::GetModuleHandleByName(MODULE("binkw32"));
 #else

src/Modules/SteamAPI.cpp

@@ -38,6 +38,8 @@ bool SteamAPI::Init() {
 
 	g_timeline->SetTimelineGameMode(k_ETimelineGameMode_Menus);
 
+	SteamUser = Memory::GetSymbolAddress<ISteamUser *(*)()>(steam_api, "SteamAPI_SteamUser_v021");
+
 	return this->hasLoaded = this->g_timeline;
 }
 void SteamAPI::Shutdown() {

src/Modules/SteamAPI.hpp

@@ -7,6 +7,8 @@ class SteamAPI : public Module {
 public:
 	ISteamTimeline *g_timeline = nullptr;
 
+	ISteamUser *(*SteamUser)();
+
 public:
 	bool Init() override;
 	void Shutdown() override;

src/SAR.cpp

@@ -32,7 +32,14 @@ bool SAR::Load(CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerF
 	console = new Console();
 	if (!console->Init())
 		return false;
-	
+
+	HANDLE handle = OpenMutexA(MUTEX_ALL_ACCESS, false, "hl2_singleton_mutex");
+	if (handle == NULL)
+		return false;
+
+	if (ReleaseMutex(handle))
+		console->Warning("Released mutex.\n");
+
 	modules = new Modules();
 	features = new Features();
 	cheats = new Cheats();

src/Utils/SDK/Other.hpp

@@ -85,25 +85,24 @@ class CPlayerState {
 };
 
 typedef struct player_info_s {
-	// network xuid
 	uint64_t xuid;
-	// scoreboard information
+
 	char name[32];
-	// local server user ID, unique while server is running
+
 	int userID;
-	// global unique player identifer
+
 	char guid[32 + 1];
-	// friends identification number
+
 	uint32_t friendsID;
-	// friends name
+
 	char friendsName[32];
-	// true, if player is a bot controlled by game.dll
+
 	bool fakeplayer;
-	// true if player is the HLTV proxy
+
 	bool ishltv;
-	// custom files CRC for this player
+
 	CRC32_t customFiles[4];
-	// this counter increases each time the server downloaded a new file
+
 	unsigned char filesDownloaded;
 } player_info_t;
 
@@ -128,10 +127,10 @@ struct PortalPlayerStatistics_t {
 };
 
 struct PortalLeaderboardItem_t {
-	uint64_t m_xuid;    //	0x0000
-	char m_szName[32];  //	0x0008
-	char pad_0028[16];  //	0x0028
-	int32_t m_iScore;   //	0x0038
+	uint64_t m_xuid;
+	char m_szName[32];
+	char pad_0028[16];
+	int32_t m_iScore;
 };
 
 enum ETimelineGameMode {
@@ -157,3 +156,71 @@ class ISteamTimeline {
 	virtual void AddTimelineEvent(const char *pchIcon, const char *pchTitle, const char *pchDescription, uint32_t unPriority, float flStartOffsetSeconds, float flDurationSeconds, ETimelineEventClipPriority ePossibleClip) = 0;
 	virtual void SetTimelineGameMode(ETimelineGameMode eMode) = 0;
 };
+
+enum EVoiceResult {
+	k_EVoiceResultOK = 0,
+	k_EVoiceResultNotInitialized = 1,
+	k_EVoiceResultNotRecording = 2,
+	k_EVoiceResultNoData = 3,
+	k_EVoiceResultBufferTooSmall = 4,
+	k_EVoiceResultDataCorrupted = 5,
+	k_EVoiceResultRestricted = 6,
+	k_EVoiceResultUnsupportedCodec = 7,
+	k_EVoiceResultReceiverOutOfDate = 8,
+	k_EVoiceResultReceiverDidNotAnswer = 9,
+
+};
+
+enum EMessage {
+	k_EMsgServerBegin = 0,
+	k_EMsgServerSendInfo = k_EMsgServerBegin + 1,
+	k_EMsgServerFailAuthentication = k_EMsgServerBegin + 2,
+	k_EMsgServerPassAuthentication = k_EMsgServerBegin + 3,
+	k_EMsgServerUpdateWorld = k_EMsgServerBegin + 4,
+	k_EMsgServerExiting = k_EMsgServerBegin + 5,
+	k_EMsgServerPingResponse = k_EMsgServerBegin + 6,
+	k_EMsgServerPlayerHitSun = k_EMsgServerBegin + 7,
+	k_EMsgClientBegin = 500,
+	k_EMsgClientBeginAuthentication = k_EMsgClientBegin + 2,
+	k_EMsgClientSendLocalUpdate = k_EMsgClientBegin + 3,
+	k_EMsgP2PBegin = 600,
+	k_EMsgP2PSendingTicket = k_EMsgP2PBegin + 1,
+	k_EMsgVoiceChatBegin = 700,
+	k_EMsgVoiceChatData = k_EMsgVoiceChatBegin + 2,
+	k_EForceDWORD = 0x7fffffff,
+};
+
+struct MsgVoiceChatData_t {
+	MsgVoiceChatData_t()
+		: m_dwMessageType((k_EMsgVoiceChatData)) {}
+	unsigned long GetMessageType() const { return (m_dwMessageType); }
+
+	void SetDataLength(uint32_t unLength) { m_uDataLength = (unLength); }
+	uint32_t GetDataLength() const { return (m_uDataLength); }
+
+	void SetSteamID(uint64_t steamID) { from_steamID = steamID; }
+	uint64_t GetSteamID() const { return from_steamID; }
+
+private:
+	const unsigned long m_dwMessageType;
+	uint32_t m_uDataLength;
+	uint64_t from_steamID;
+};
+
+class ISteamUser {
+public:
+	virtual void *GetHSteamUser() = 0;
+	virtual bool BLoggedOn() = 0;
+	virtual uint64_t GetSteamID() = 0;
+	virtual int InitiateGameConnection_DEPRECATED(void *pAuthBlob, int cbMaxAuthBlob, uint64_t steamIDGameServer, uint32_t unIPServer, uint16_t usPortServer, bool bSecure) = 0;
+	virtual void TerminateGameConnection_DEPRECATED(uint32_t unIPServer, uint16_t usPortServer) = 0;
+	virtual void TrackAppUsageEvent(uint64_t gameID, int eAppUsageEvent, const char *pchExtraInfo = "") = 0;
+	virtual bool GetUserDataFolder(char *pchBuffer, int cubBuffer) = 0;
+	virtual void StartVoiceRecording() = 0;
+	virtual void StopVoiceRecording() = 0;
+	virtual EVoiceResult GetAvailableVoice(uint32_t *pcbCompressed, uint32_t *pcbUncompressed_Deprecated = 0, uint32_t nUncompressedVoiceDesiredSampleRate_Deprecated = 0) = 0;
+	virtual EVoiceResult GetVoice(bool bWantCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, bool bWantUncompressed_Deprecated = false, void *pUncompressedDestBuffer_Deprecated = 0, uint32_t cbUncompressedDestBufferSize_Deprecated = 0, uint32_t *nUncompressBytesWritten_Deprecated = 0, uint32_t nUncompressedVoiceDesiredSampleRate_Deprecated = 0) = 0;
+	virtual EVoiceResult DecompressVoice(const void *pCompressed, uint32_t cbCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t nDesiredSampleRate) = 0;
+	virtual uint32_t GetVoiceOptimalSampleRate() = 0;
+	// don't need the rest.
+};