Files
SatyandClaude Opus 5.5 c790ecb4a0 Port Streaming/Storage/Transport/HTTP, Mopaq write path and missing-function batches
- Streaming: StreamingManager, Manifests, Storage (.part files, write queue),
  Transport (HTTP split download, throttle), Tracker/StartupReport, streaming
  filestack verbs (s_streamstack, StreamingOpen), RepairCache static
- URL: HttpRequest, InternetCallback, ReadResponseData, DownloadURL
- Mopaq write path: SFileCreateArchive/CreateFile/WriteFile, IOMpqWriteUnit,
  WriteArchiveChanges, RebuildHashTable, listfile acquire/release;
  SComp::Compress with RLE/zlib/bzip2/pkware compressors; MPQEncrypt::Encrypt
- LaunchChildProcessWithArguments, Debug::DefaultCallback/Breakpoint
- Earlier batches: ComSat, Battlenet Tumor, Glue/Ui/WowServices fixes,
  luaL_error returns in Script_ files

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-10-03 16:51:23 +02:00

1179 lines
45 KiB
C++

#include "Engine/Source/ComSat/ComSatSoundManager.h"
#include "Engine/Source/ComSat/ComSatAllocator.h"
#include "Engine/Source/ComSat/ComSatSoundLevelCalculator.h"
#include "Engine/Source/Os/Processor.h"
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <new>
// STATIC: 0x00D43990
static uint32_t s_lastEncodeTime;
// STATIC: 0x00D43994
static int32_t s_jitterBufferSize = (ComSat::Sound::CODECIPMR6000::s_sampleRate * ComSat::Sound::CODECIPMR6000::s_bitsPerSample / 8) / ComSat::Sound::CODECIPMR6000::s_bytesPerFrame;
// STATIC: 0x00D43998
static int32_t s_frameTimeWindow = (ComSat::Sound::CODECIPMR6000::s_sampleRate * ComSat::Sound::CODECIPMR6000::s_bitsPerSample / 8 * 2) / ComSat::Sound::CODECIPMR6000::s_bytesPerFrame;
// VERIFY: 83e2f3a6 auto
// OFFSET: 0x0087F930
ComSat::Sound::Manager::Callback::~Callback() {
}
// VERIFY: 58ec21e6 auto
// OFFSET: 0x00881260
ComSat::Sound::Manager::RemoteTalker::RemoteTalker(ComSat::Allocator& allocator) : m_allocator(&allocator), m_packets(nullptr), m_frameTime(allocator) {
this->m_packets = static_cast<VoicePacket*>(allocator.Alloc(sizeof(VoicePacket) * s_jitterBufferSize));
}
// VERIFY: 68ac5962 auto
// OFFSET: 0x008812B0
void ComSat::Sound::Manager::SetCallback(ComSat::Sound::Manager::Callback* callback) {
this->m_callback = callback;
}
// VERIFY: 95032179 auto
// OFFSET: 0x008812C0
bool ComSat::Sound::Manager::LocalTalkerChangeOutputDevice(uint8_t player, int32_t device) {
if (this->m_io) {
return this->m_io->LocalPlayerChangeOutputDevice(player, device);
}
return false;
}
// VERIFY: f7e4bc4b auto
// OFFSET: 0x008812E0
bool ComSat::Sound::Manager::LocalTalkerChangeCaptureDevice(uint8_t player, int32_t device) {
if (this->m_io) {
return this->m_io->LocalPlayerChangeCaptureDevice(player, device);
}
return false;
}
// VERIFY: eab244f7 manual
// OFFSET: 0x00881300
int32_t ComSat::Sound::Manager::LocalTalkerGetCurrentOutputDeviceIndex(uint8_t player) {
if (this->m_io) {
return this->m_io->LocalPlayerGetCurrentOutputDeviceIndex(player);
}
return -1;
}
// VERIFY: dbc4fd0b manual
// OFFSET: 0x00881320
int32_t ComSat::Sound::Manager::LocalTalkerGetCurrentCaptureDeviceIndex(uint8_t player) {
if (this->m_io) {
return this->m_io->LocalPlayerGetCurrentCaptureDeviceIndex(player);
}
return -1;
}
// VERIFY: 6af853ca manual
// OFFSET: 0x00881340
bool ComSat::Sound::Manager::LocalTalkerThreshold(uint8_t player, float threshold) {
if (!this->m_codec) {
return false;
}
this->m_codec->SetThreshold(player, threshold);
return true;
}
// VERIFY: 7e70ce48 auto
// OFFSET: 0x00881370
bool ComSat::Sound::Manager::CanBitpackEncodedData() {
return ComSat::Sound::CODEC::CanBitpackFrames();
}
// VERIFY: 996b2e46 auto
// OFFSET: 0x00881370
bool ComSat::Sound::Manager::IsUsingVariableBitrateCodec() {
return ComSat::Sound::CODEC::IsEncodedBitrateVariable();
}
// VERIFY: 5b24b547 auto
// OFFSET: 0x00881380
int32_t ComSat::Sound::Manager::GetMinEncodedFrameLength() {
return ComSat::Sound::CODECIPMR6000::s_minEncodedFrameLength;
}
// VERIFY: b74c7db0 auto
// OFFSET: 0x00881390
int32_t ComSat::Sound::Manager::GetMaxEncodedFrameLength() {
return ComSat::Sound::CODECIPMR6000::s_maxEncodedFrameLength;
}
// VERIFY: 7308e0a0 auto
// OFFSET: 0x00437720
bool ComSat::Sound::Manager::IsRemoteTalkerTalkingInSession(uint64_t session, uint8_t player, uint64_t talker) {
return false;
}
// VERIFY: 2049629b auto
// OFFSET: 0x008813A0
bool ComSat::Sound::Manager::IsLocalPlayerTalking(uint8_t player) {
return false;
}
// VERIFY: c4f9bc66 manual
// OFFSET: 0x008813B0
int32_t ComSat::Sound::Manager::EnumerateOutputDevices(ComSat::DeviceInfo* devices, int32_t maxDevices) {
if (!this->m_io) {
return 0;
}
return this->m_io->EnumerateOutputDevices(devices, maxDevices);
}
// VERIFY: e5b0261b manual
// OFFSET: 0x008813D0
int32_t ComSat::Sound::Manager::EnumerateCaptureDevices(ComSat::DeviceInfo* devices, int32_t maxDevices) {
if (!this->m_io) {
return 0;
}
return this->m_io->EnumerateCaptureDevices(devices, maxDevices);
}
// VERIFY: cf900560 manual
// OFFSET: 0x008813F0
void ComSat::Sound::Manager::AdvancePlayCursorForRemoteTalker(ComSat::Sound::Manager::RemoteTalker* talker) {
int32_t cursor = static_cast<int32_t>(talker->m_playCursor);
talker->m_playCursor += ComSat::Sound::CODECIPMR6000::s_samplesPerFrame * 1000.0f / ComSat::Sound::CODECIPMR6000::s_sampleRate / talker->m_frameTime.GetCurrentAverage();
int32_t end = static_cast<int32_t>(talker->m_playCursor) % s_jitterBufferSize;
talker->m_playCursor = fmod(talker->m_playCursor, static_cast<double>(s_jitterBufferSize));
for (; cursor != end; cursor = (cursor + 1) % s_jitterBufferSize) {
talker->m_packets[cursor].m_valid = false;
}
}
// VERIFY: ced4a441 auto
// OFFSET: 0x00881480
void ComSat::Sound::Manager::DebugSetSequenceDelay(int32_t delay) {
this->m_sequenceDelay = this->m_jitterDelay + delay;
}
// VERIFY: de383fb8 manual
// OFFSET: 0x00881490
void ComSat::Sound::Manager::DebugSetSoundOutputDelay(uint8_t player, int32_t delay) {
if (this->m_io) {
this->m_io->DebugSetSoundOutputDelay(player, delay);
}
}
// VERIFY: 7e52a2ba auto
// OFFSET: 0x008814F0
ComSat::Sound::Manager::RemoteTalker::~RemoteTalker() {
this->m_allocator->Free(this->m_packets);
}
// VERIFY: b4173bb3 auto
// OFFSET: 0x00881C50
ComSat::Sound::Manager::LocalPlayer::~LocalPlayer() {
}
// VERIFY: 73854b3e auto
// OFFSET: 0x00881CA0
ComSat::Sound::Manager::LocalPlayer::LocalPlayer(ComSat::Allocator& allocator) : m_sessionPriorities(allocator), m_mutedSessions(allocator), m_mutedTalkers(allocator), m_talkerVolumes(allocator), m_sessionVolumes(allocator) {
}
// INLINED
ComSat::Sound::Manager::Session::Session(ComSat::Allocator& allocator) : m_id(0), m_talkerPriorities(allocator) {
}
// VERIFY: 4458ca17 manual
// OFFSET: 0x00881CF0
ComSat::Sound::Manager::Manager(const ComSat::Initialization& init, ComSat::Allocator& allocator) : m_localPlayers(allocator), m_sessions(allocator), m_remoteTalkers(allocator) {
this->m_maxLocalPlayers = init.m_maxLocalPlayers;
this->m_allocator = &allocator;
this->m_callback = nullptr;
this->m_codec = nullptr;
this->m_io = ComSat::Sound::IO::Create(init, *this, allocator);
this->m_jitterDelay = 5;
this->m_sequenceDelay = 5;
this->m_maxChannels = init.m_maxChannels;
this->m_currentFrame = 0;
this->m_startTime = init.m_time;
this->m_currentTime = init.m_time;
if (OsGetProcessorFeatures() & 4) {
this->m_codec = ComSat::Sound::CODEC::Create(init, allocator);
int32_t bytesPerSecond = ComSat::Sound::CODECIPMR6000::s_sampleRate * ComSat::Sound::CODECIPMR6000::s_bitsPerSample / 8;
this->m_framesPerSecond = static_cast<float>(bytesPerSecond) / ComSat::Sound::CODECIPMR6000::s_bytesPerFrame;
this->m_holdFrames = static_cast<int32_t>(ceil(this->m_framesPerSecond * 500.0f * 0.001f));
this->m_frameDuration = ComSat::Sound::CODECIPMR6000::s_samplesPerFrame * 1000.0f / ComSat::Sound::CODECIPMR6000::s_sampleRate;
this->m_jitterDelay = static_cast<int32_t>(this->m_framesPerSecond * 0.1f);
if (!this->m_jitterDelay) {
this->m_jitterDelay = 1;
}
this->m_sequenceDelay = 2 * this->m_jitterDelay;
}
}
// VERIFY: 2e83be4f manual
// OFFSET: 0x00881E20
bool ComSat::Sound::Manager::LocalTalkerEnable(uint8_t player, bool enable) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
if (!enable && localPlayer->m_enabled && this->m_callback) {
this->m_callback->LocalChatDataReady(player, nullptr, 0, 0);
}
localPlayer->m_enabled = enable;
return true;
}
// VERIFY: ed8ef859 auto
// OFFSET: 0x00881EC0
bool ComSat::Sound::Manager::LocalTalkerEnableVoiceLevelCallback(uint8_t player, bool enable) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
localPlayer->m_voiceLevelCallback = enable;
return true;
}
// VERIFY: c25f698a manual
// OFFSET: 0x00881F30
int32_t ComSat::Sound::Manager::SessionNumMembers(uint64_t session) {
Session* info;
if (!this->m_sessions.Get(ComSat::MapKey<uint64_t>(session), info)) {
return -1;
}
int32_t count = info->m_talkerPriorities.m_used;
uint32_t iterator = 0;
ComSat::MapKey<uint8_t> key;
LocalPlayer* localPlayer;
while (this->m_localPlayers.Next(iterator, key, localPlayer)) {
uint32_t index;
if (localPlayer->m_sessionPriorities.Find(ComSat::MapKey<uint64_t>(session), index)) {
count++;
}
}
return count;
}
// VERIFY: b51edc25 manual
// OFFSET: 0x00882030
bool ComSat::Sound::Manager::SessionGetTalkerByIndex(uint64_t session, int32_t index, uint64_t& talker, uint8_t& player) {
if (index >= this->SessionNumMembers(session)) {
return false;
}
int32_t count = 0;
LocalPlayer* localPlayer = nullptr;
uint32_t iterator = 0;
ComSat::MapKey<uint8_t> playerKey;
while (this->m_localPlayers.Next(iterator, playerKey, localPlayer)) {
uint32_t found;
if (localPlayer->m_sessionPriorities.Find(ComSat::MapKey<uint64_t>(session), found)) {
if (index == count) {
talker = 0;
player = playerKey.m_value;
return true;
}
count++;
}
}
player = 0xFF;
iterator = 0;
Session* info;
if (!this->m_sessions.Get(ComSat::MapKey<uint64_t>(session), info)) {
return false;
}
ComSat::MapKey<uint64_t> talkerKey;
uint8_t priority;
if (info->m_talkerPriorities.Next(iterator, talkerKey, priority)) {
while (count < index) {
count++;
if (!info->m_talkerPriorities.Next(iterator, talkerKey, priority)) {
break;
}
}
}
if (count != index) {
return false;
}
talker = talkerKey.m_value;
return true;
}
// VERIFY: 8f19331f manual
// OFFSET: 0x008821C0
void ComSat::Sound::Manager::RecenterJitterBufferForRemoteTalker(uint64_t talker, int32_t offset) {
RemoteTalker* remote;
if (!this->m_remoteTalkers.Get(ComSat::MapKey<uint64_t>(talker), remote)) {
return;
}
VoicePacket* packets = static_cast<VoicePacket*>(this->m_allocator->Alloc(sizeof(VoicePacket) * s_jitterBufferSize));
memcpy(packets, remote->m_packets, sizeof(VoicePacket) * s_jitterBufferSize);
for (int32_t i = 0; i < s_jitterBufferSize; i++) {
remote->m_packets[i].m_valid = false;
}
int32_t cursor = static_cast<int32_t>(remote->m_playCursor);
for (int32_t i = 0; i < s_jitterBufferSize; i++) {
if (!packets[i].m_valid) {
continue;
}
int32_t slot = (offset + i) % s_jitterBufferSize;
if (slot < 0) {
slot += s_jitterBufferSize;
}
int32_t delay = this->m_jitterDelay;
int32_t remaining = s_jitterBufferSize - cursor;
if (slot < cursor) {
if (remaining >= delay) {
memcpy(&remote->m_packets[slot], &packets[i], sizeof(VoicePacket));
continue;
}
delay -= s_jitterBufferSize;
} else if (remaining < delay) {
continue;
}
if (slot >= cursor + delay) {
memcpy(&remote->m_packets[slot], &packets[i], sizeof(VoicePacket));
}
}
this->m_allocator->Free(packets);
}
// VERIFY: 6b28c289 auto
// OFFSET: 0x00882330
void ComSat::Sound::Manager::SubmitIncomingFrameTimeData(uint64_t talker, uint16_t sequence) {
RemoteTalker* remote;
if (!this->m_remoteTalkers.Get(ComSat::MapKey<uint64_t>(talker), remote)) {
return;
}
uint32_t lastTime = remote->m_lastPacketTime;
if (lastTime && lastTime != this->m_currentTime) {
double elapsed = static_cast<double>(this->m_currentTime) - lastTime;
uint16_t lastSequence = remote->m_lastSequence;
int32_t frames = sequence - lastSequence;
if (frames < 0) {
frames += 0x10000;
}
if (frames > 0 && lastSequence) {
if (frames > s_frameTimeWindow) {
frames = s_frameTimeWindow;
}
if (frames > 0) {
double frameTime = elapsed / frames;
for (int32_t i = frames; i; i--) {
remote->m_frameTime.SubmitData(frameTime);
}
}
}
remote->m_lastSequence = sequence;
}
remote->m_lastPacketTime = this->m_currentTime;
}
// VERIFY: 35250d18 manual
// OFFSET: 0x00882440
void ComSat::Sound::Manager::SubmitIncomingVoicePacket(uint64_t session, uint64_t talker, uint8_t* data, uint32_t size, bool reliable) {
if (size > static_cast<uint32_t>(ComSat::Sound::CODECIPMR6000::s_maxEncodedFrameLength + 4)) {
return;
}
RemoteTalker* remote;
if (!this->m_remoteTalkers.Get(ComSat::MapKey<uint64_t>(talker), remote)) {
return;
}
VoicePacket* packets = remote->m_packets;
VoicePacket* packet = reinterpret_cast<VoicePacket*>(data);
int32_t cursor = static_cast<int32_t>(remote->m_playCursor);
int32_t slot = cursor;
int32_t skipped = 0;
int32_t target;
while (!packets[slot].m_valid) {
slot = (slot + 1) % s_jitterBufferSize;
skipped++;
if (slot == cursor) {
target = (cursor + this->m_sequenceDelay) % s_jitterBufferSize;
remote->m_recenterTime = this->m_currentTime;
goto store;
}
}
target = cursor + skipped + (packet->m_sequence - packets[slot].m_sequence);
if (this->m_currentTime != remote->m_recenterTime && !reliable) {
remote->m_recenterTime = this->m_currentTime;
int32_t expected = cursor + this->m_sequenceDelay;
if (abs(target - expected) > 2) {
int32_t delta = expected - target;
target = expected;
this->RecenterJitterBufferForRemoteTalker(talker, delta);
}
}
store:
int32_t index = (target < 0 ? 0 : target) % s_jitterBufferSize;
memcpy(&remote->m_packets[index], data, size);
remote->m_packets[index].m_valid = true;
remote->m_packets[index].m_session = session;
}
// VERIFY: ff2f231b manual
// OFFSET: 0x008825D0
uint32_t ComSat::Sound::Manager::CalculateTotalVoicePriorityForRemoteTalkerInSessionForLocalPlayer(uint8_t player, uint64_t talker, uint64_t session) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return 0;
}
uint32_t index;
if (localPlayer->m_mutedSessions.Find(session, index)) {
return 0;
}
if (localPlayer->m_mutedTalkers.Find(talker, index)) {
return 0;
}
uint8_t sessionPriority = 0;
if (!localPlayer->m_sessionPriorities.Get(ComSat::MapKey<uint64_t>(session), sessionPriority)) {
return 0;
}
Session* info;
if (sessionPriority && this->m_sessions.Get(ComSat::MapKey<uint64_t>(session), info)) {
uint8_t talkerPriority = 0;
if (info->m_talkerPriorities.Get(ComSat::MapKey<uint64_t>(talker), talkerPriority) && talkerPriority) {
return talkerPriority + (sessionPriority << 8);
}
}
return 0;
}
// VERIFY: 667d951e manual
// OFFSET: 0x00882700
bool ComSat::Sound::Manager::DecodeVoicePacket(uint8_t player, int32_t channel, ComSat::Sound::Manager::VoicePacket* packet, uint32_t* size) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
*size = sizeof(localPlayer->m_buffer);
return this->m_codec->DecompressEncodedData(player, channel, packet->m_data, packet->m_bits, localPlayer->m_buffer, size);
}
// VERIFY: 1c265579 auto
// OFFSET: 0x00882780
void ComSat::Sound::Manager::WriteVoiceDataToHeadsetDeviceBuffer(uint8_t player, int32_t channel, uint32_t size, double rate) {
if (!size) {
return;
}
LocalPlayer* localPlayer;
if (this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer) && this->m_io) {
this->m_io->PlayDataForPlayer(player, channel, localPlayer->m_buffer, size, rate);
}
}
// VERIFY: 9c3ab779 auto
// OFFSET: 0x00882810
void ComSat::Sound::Manager::TransferEncodedVoiceDataForLocalPlayer(uint8_t player, const uint8_t* data, uint32_t bits, uint32_t time) {
if (!data || bits > static_cast<uint32_t>(ComSat::Sound::CODECIPMR6000::s_maxEncodedFrameLength) || bits < static_cast<uint32_t>(ComSat::Sound::CODECIPMR6000::s_minEncodedFrameLength)) {
return;
}
LocalPlayer* localPlayer;
if (this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
uint32_t bytes = bits >> 3;
VoicePacket packet;
packet.m_sequence = localPlayer->m_sequence;
packet.m_bits = bits;
if (bits & 7) {
bytes++;
}
memcpy(packet.m_data, data, bytes);
this->m_callback->LocalChatDataReady(player, reinterpret_cast<uint8_t*>(&packet), bytes + 4, time);
}
}
// VERIFY: abf0507c auto
// OFFSET: 0x008828E0
bool ComSat::Sound::Manager::IsRemoteTalkerMuted(uint8_t player, uint64_t talker) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
uint32_t index;
return localPlayer->m_mutedTalkers.Find(talker, index);
}
// VERIFY: e3a12132 manual
// OFFSET: 0x00882950
bool ComSat::Sound::Manager::SetTalkerMuted(uint8_t player, uint64_t talker, ComSat::MuteSetting setting) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
uint32_t index;
bool mute = setting == ComSat::MUTE_SETTING_MUTE;
if ((setting == ComSat::MUTE_SETTING_TOGGLE && !localPlayer->m_mutedTalkers.Find(talker, index)) || mute) {
if (!localPlayer->m_mutedTalkers.Find(talker, index)) {
localPlayer->m_mutedTalkers.PushBack(talker);
}
return true;
}
return localPlayer->m_mutedTalkers.Remove(talker);
}
// VERIFY: b712fdb6 auto
// OFFSET: 0x00882A00
bool ComSat::Sound::Manager::IsSessionMuted(uint8_t player, uint64_t session) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
uint32_t index;
return localPlayer->m_mutedSessions.Find(session, index);
}
// VERIFY: d8c69071 manual
// OFFSET: 0x00882A70
bool ComSat::Sound::Manager::SetSessionMuted(uint8_t player, uint64_t session, ComSat::MuteSetting setting) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
uint32_t index;
bool mute = setting == ComSat::MUTE_SETTING_MUTE;
if ((setting == ComSat::MUTE_SETTING_TOGGLE && !localPlayer->m_mutedSessions.Find(session, index)) || mute) {
if (!localPlayer->m_mutedSessions.Find(session, index)) {
localPlayer->m_mutedSessions.PushBack(session);
}
return true;
}
return localPlayer->m_mutedSessions.Remove(session);
}
// VERIFY: df093e1a auto
// OFFSET: 0x00882B20
void ComSat::Sound::Manager::DeviceError(uint8_t player) {
LocalPlayer* localPlayer;
if (this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer) && !localPlayer->m_deviceError) {
localPlayer->m_deviceError = true;
this->m_callback->DeviceError(player);
}
}
// VERIFY: 6fa4598d manual
// OFFSET: 0x00882CE0
void ComSat::Sound::Manager::AssignTalkersToChannelsForLocalPlayer(uint8_t player, int32_t channelCount, ComSat::Sound::Manager::TalkingTalkerInfo* infos) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return;
}
uint32_t priorities[4];
if (channelCount > 0) {
memset(priorities, 0, sizeof(uint32_t) * channelCount);
for (int32_t i = 0; i < channelCount; i++) {
infos[i].m_talker = 0;
infos[i].m_session = 0;
infos[i].m_active = false;
}
}
for (int32_t c = 0; c < channelCount; c++) {
TalkingTalkerInfo& current = localPlayer->m_channels[c];
if (!current.m_talker) {
continue;
}
uint64_t talker = current.m_talker;
uint64_t session = current.m_session;
RemoteTalker* remote;
if (!this->m_remoteTalkers.Get(ComSat::MapKey<uint64_t>(talker), remote)) {
continue;
}
double average = remote->m_frameTime.GetCurrentAverage();
uint64_t best = 0;
uint8_t bestPriority = 0;
int32_t end = static_cast<int32_t>(ComSat::Sound::CODECIPMR6000::s_samplesPerFrame * 1000.0f / ComSat::Sound::CODECIPMR6000::s_sampleRate / average + remote->m_playCursor) % s_jitterBufferSize;
for (int32_t slot = static_cast<int32_t>(remote->m_playCursor); slot != end; slot = (slot + 1) % s_jitterBufferSize) {
VoicePacket& packet = remote->m_packets[slot];
if (packet.m_valid) {
uint8_t priority;
if (localPlayer->m_sessionPriorities.Get(ComSat::MapKey<uint64_t>(packet.m_session), priority) && priority > bestPriority) {
bestPriority = priority;
best = remote->m_packets[slot].m_session;
}
}
}
if (best == session || !best) {
uint32_t total = this->CalculateTotalVoicePriorityForRemoteTalkerInSessionForLocalPlayer(player, talker, session);
if (total) {
infos[c].m_talker = current.m_talker;
infos[c].m_session = current.m_session;
infos[c].m_active = best == session;
infos[c].m_holdFrames = current.m_holdFrames;
priorities[c] = total;
}
}
}
uint32_t iterator = 0;
ComSat::MapKey<uint64_t> key;
RemoteTalker* remote;
while (this->m_remoteTalkers.Next(iterator, key, remote)) {
uint64_t talker = remote->m_guid;
uint64_t best = 0;
double average = remote->m_frameTime.GetCurrentAverage();
bool assigned = false;
if (channelCount > 0) {
for (int32_t i = 0; i < channelCount; i++) {
if (infos[i].m_talker == talker) {
assigned = true;
}
}
if (assigned) {
continue;
}
}
uint8_t bestPriority = 0;
int32_t end = static_cast<int32_t>(ComSat::Sound::CODECIPMR6000::s_samplesPerFrame * 1000.0f / ComSat::Sound::CODECIPMR6000::s_sampleRate / average + remote->m_playCursor) % s_jitterBufferSize;
int32_t slot = static_cast<int32_t>(remote->m_playCursor);
if (slot == end) {
continue;
}
do {
VoicePacket& packet = remote->m_packets[slot];
if (packet.m_valid) {
uint8_t priority;
if (localPlayer->m_sessionPriorities.Get(ComSat::MapKey<uint64_t>(packet.m_session), priority) && priority > bestPriority) {
bestPriority = priority;
best = remote->m_packets[slot].m_session;
}
}
slot = (slot + 1) % s_jitterBufferSize;
} while (slot != end);
if (!best) {
continue;
}
uint32_t total = this->CalculateTotalVoicePriorityForRemoteTalkerInSessionForLocalPlayer(player, talker, best);
int32_t replace = -1;
if (channelCount > 0) {
for (int32_t i = 0; i < channelCount; i++) {
if (total > priorities[i] && (replace == -1 || priorities[i] < priorities[replace])) {
replace = i;
}
}
if (replace != -1) {
priorities[replace] = total;
infos[replace].m_talker = talker;
infos[replace].m_session = best;
infos[replace].m_active = true;
}
}
}
}
// VERIFY: 2abf7a9a manual
// OFFSET: 0x008831C0
void ComSat::Sound::Manager::GenerateAndWriteSilenceToHeadsetDeviceBuffer(uint8_t player, int32_t channel, float frames, double rate) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return;
}
this->m_codec->GenerateSilence(localPlayer->m_buffer, ComSat::Sound::CODECIPMR6000::s_bytesPerFrame);
while (frames >= 1.0f) {
this->WriteVoiceDataToHeadsetDeviceBuffer(player, channel, ComSat::Sound::CODECIPMR6000::s_bytesPerFrame, rate);
frames -= 1.0f;
}
}
// VERIFY: 4067ca64 auto
// OFFSET: 0x00883270
void ComSat::Sound::Manager::EncodeAvailableVoiceDataForLocalPlayer(uint8_t player, ComSat::Sound::Manager::LocalPlayer* localPlayer) {
if (!this->m_io || !this->m_codec) {
return;
}
int32_t available = this->m_io->GetAvailableDataBytes(player);
int32_t attempts = 5;
if (!available) {
return;
}
int32_t blockSize = ComSat::Sound::CODECIPMR6000::s_samplesPerFrame * ComSat::Sound::CODECIPMR6000::s_bitsPerSample / 8;
if (available < blockSize) {
return;
}
while (attempts-- > 0) {
int32_t read = this->m_io->ReadDataForPlayer(player, localPlayer->m_buffer, blockSize);
s_lastEncodeTime = this->m_currentTime;
if (read < blockSize) {
break;
}
int32_t remaining = this->m_io->GetAvailableDataBytes(player);
uint32_t bits = 1024;
uint8_t encoded[128];
bool transmit = localPlayer->m_enabled;
uint32_t sequence = localPlayer->m_sequence;
if (sequence < localPlayer->m_lastResetSequence) {
sequence += 0x10000;
}
if (sequence - localPlayer->m_lastResetSequence >= static_cast<uint32_t>(ComSat::Sound::CODEC::MinimumSafeFramesBetweenResets()) && ComSat::Sound::CODEC::MinimumSafeFramesBetweenResets() && !(localPlayer->m_sequence % static_cast<int32_t>(ComSat::Sound::CODEC::MinimumSafeFramesBetweenResets()))) {
localPlayer->m_resetEncoder = true;
}
if (transmit || localPlayer->m_voiceLevelCallback) {
if (localPlayer->m_resetEncoder) {
this->m_codec->ResetPlayerChannelEncoder(player);
localPlayer->m_resetEncoder = false;
localPlayer->m_lastResetSequence = localPlayer->m_sequence;
}
bool voice = false;
if (!this->m_codec->CompressRawData(player, localPlayer->m_buffer, blockSize, encoded, &bits, &voice)) {
transmit = false;
}
if (!voice) {
transmit = false;
localPlayer->m_resetEncoder = true;
}
if (localPlayer->m_voiceLevelCallback) {
float level = 0.0f;
float decibels = 0.0f;
ComSat::Sound::LevelCalculator16Bit::CalculateLevelForFrame(localPlayer->m_buffer, blockSize, level, decibels);
this->m_callback->LocalTalkerVoiceLevel(player, level, voice);
}
}
if (transmit) {
int32_t bytesPerSecond = ComSat::Sound::CODECIPMR6000::s_sampleRate * ComSat::Sound::CODECIPMR6000::s_bitsPerSample / 8;
this->TransferEncodedVoiceDataForLocalPlayer(player, encoded, bits, 1000u / static_cast<uint32_t>(bytesPerSecond / blockSize));
localPlayer->m_talking = true;
} else if (localPlayer->m_talking && this->m_callback) {
this->m_callback->LocalChatDataReady(player, nullptr, 0, 0);
localPlayer->m_talking = false;
}
localPlayer->m_sequence++;
if (remaining < blockSize) {
break;
}
}
}
// VERIFY: a3cc71d9 manual
// OFFSET: 0x00883950
bool ComSat::Sound::Manager::InitLocalPlayer(uint8_t player, float threshold, int32_t outputDevice, int32_t captureDevice) {
uint32_t index;
if (this->m_localPlayers.Find(ComSat::MapKey<uint8_t>(player), index)) {
return false;
}
LocalPlayer* localPlayer = new (this->m_allocator->Alloc(sizeof(LocalPlayer))) LocalPlayer(*this->m_allocator);
localPlayer->m_sequence = 0;
localPlayer->m_enabled = false;
localPlayer->m_talking = false;
localPlayer->m_deviceError = false;
localPlayer->m_voiceLevelCallback = false;
localPlayer->m_lastResetSequence = 0;
for (int32_t i = 0; i < 4; i++) {
localPlayer->m_channels[i].m_talker = 0;
localPlayer->m_channels[i].m_session = 0;
localPlayer->m_channels[i].m_active = false;
localPlayer->m_channels[i].m_holdFrames = 0;
}
this->m_localPlayers.Insert(ComSat::MapKey<uint8_t>(player), localPlayer);
if (this->m_io) {
this->m_io->InitLocalPlayer(player, outputDevice, captureDevice, ComSat::Sound::CODECIPMR6000::s_sampleRate, ComSat::Sound::CODECIPMR6000::s_bitsPerSample, ComSat::Sound::CODECIPMR6000::s_samplesPerFrame);
}
if (this->m_codec) {
this->m_codec->InitLocalPlayer(player, threshold);
}
return true;
}
// VERIFY: d85d2efb auto
// OFFSET: 0x00883A90
bool ComSat::Sound::Manager::LocalTalkerSetRemoteTalkerVolume(uint8_t player, uint64_t talker, float volume) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
localPlayer->m_talkerVolumes[ComSat::MapKey<uint64_t>(talker)] = volume;
return true;
}
// VERIFY: 6aaa876a auto
// OFFSET: 0x00883B30
bool ComSat::Sound::Manager::LocalTalkerSetSessionVolume(uint8_t player, uint64_t session, float volume) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
localPlayer->m_sessionVolumes[ComSat::MapKey<uint64_t>(session)] = volume;
return true;
}
// VERIFY: 7f3bf85f manual
// OFFSET: 0x00883BD0
bool ComSat::Sound::Manager::SessionCreate(uint64_t session) {
uint32_t index;
if (!this->m_sessions.Find(ComSat::MapKey<uint64_t>(session), index)) {
Session* info = new (this->m_allocator->Alloc(sizeof(Session))) Session(*this->m_allocator);
info->m_id = session;
this->m_sessions.Insert(ComSat::MapKey<uint64_t>(session), info);
}
return true;
}
// VERIFY: a8653a42 manual
// OFFSET: 0x00883C90
bool ComSat::Sound::Manager::RegisterLocalTalkerForSession(uint64_t session, uint8_t player) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
uint32_t index;
if (!this->m_sessions.Find(ComSat::MapKey<uint64_t>(session), index)) {
return false;
}
localPlayer->m_sessionPriorities[ComSat::MapKey<uint64_t>(session)] = 0x80;
localPlayer->m_sessionVolumes[ComSat::MapKey<uint64_t>(session)] = 1.0f;
localPlayer->m_mutedSessions.Remove(session);
return true;
}
// VERIFY: 63bf831f manual
// OFFSET: 0x00883DB0
bool ComSat::Sound::Manager::RegisterRemoteTalkerForSession(uint64_t session, uint64_t talker) {
Session* info;
if (!this->m_sessions.Get(ComSat::MapKey<uint64_t>(session), info)) {
return false;
}
uint32_t index;
if (!this->m_remoteTalkers.Find(ComSat::MapKey<uint64_t>(talker), index)) {
RemoteTalker* remote = new (this->m_allocator->Alloc(sizeof(RemoteTalker))) RemoteTalker(*this->m_allocator);
remote->m_guid = talker;
for (int32_t i = 0; i < s_jitterBufferSize; i++) {
remote->m_packets[i].m_valid = false;
}
remote->m_frameTime.Init(this->m_frameDuration, s_frameTimeWindow);
remote->m_lastPacketTime = 0;
remote->m_lastSequence = 0;
remote->m_playCursor = 0.0;
remote->m_lastResetSequence = 0;
this->m_remoteTalkers.Insert(ComSat::MapKey<uint64_t>(talker), remote);
}
if (!info->m_talkerPriorities.Find(ComSat::MapKey<uint64_t>(talker), index)) {
info->m_talkerPriorities[ComSat::MapKey<uint64_t>(talker)] = 0x80;
}
return true;
}
// VERIFY: 0149312b auto
// OFFSET: 0x00883F90
bool ComSat::Sound::Manager::SetPlaybackPriorityForPlayerInSession(uint64_t session, uint64_t talker, uint8_t priority) {
Session* info;
if (!this->m_sessions.Get(ComSat::MapKey<uint64_t>(session), info)) {
return false;
}
info->m_talkerPriorities[ComSat::MapKey<uint64_t>(talker)] = priority;
return true;
}
// VERIFY: f96bfd70 auto
// OFFSET: 0x00884030
bool ComSat::Sound::Manager::SetPlaybackPriorityForSession(uint64_t session, uint8_t player, uint8_t priority) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
localPlayer->m_sessionPriorities[ComSat::MapKey<uint64_t>(session)] = priority;
return true;
}
// VERIFY: 7684e1bc manual
// OFFSET: 0x008840D0
void ComSat::Sound::Manager::PlayVoiceDataForLocalPlayer(uint8_t player, int32_t frames) {
bool reset = false;
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return;
}
int32_t channelCount = this->m_maxChannels;
TalkingTalkerInfo infos[4];
for (int32_t i = 0; i < 4; i++) {
infos[i].m_talker = 0;
infos[i].m_session = 0;
infos[i].m_active = false;
}
for (int32_t c = 0; c < channelCount; c++) {
TalkingTalkerInfo& channel = localPlayer->m_channels[c];
if (channel.m_talker && --channel.m_holdFrames <= 0) {
channel.m_talker = 0;
channel.m_session = 0;
channel.m_holdFrames = 0;
}
}
this->AssignTalkersToChannelsForLocalPlayer(player, channelCount, infos);
for (int32_t c = 0; c < channelCount; c++) {
TalkingTalkerInfo& info = infos[c];
TalkingTalkerInfo& channel = localPlayer->m_channels[c];
if (info.m_talker && info.m_active && (channel.m_talker != info.m_talker || channel.m_session != info.m_session || !channel.m_active)) {
uint32_t index;
if (this->m_remoteTalkers.Find(ComSat::MapKey<uint64_t>(info.m_talker), index)) {
this->m_callback->RemotePlayerTalkNotifyStart(player, info.m_talker, info.m_session);
reset = true;
}
}
}
for (int32_t c = 0; c < channelCount; c++) {
TalkingTalkerInfo& info = infos[c];
TalkingTalkerInfo& channel = localPlayer->m_channels[c];
if (channel.m_talker && channel.m_active && (info.m_talker != channel.m_talker || info.m_session != channel.m_session || !info.m_active)) {
uint32_t index;
if (this->m_remoteTalkers.Find(ComSat::MapKey<uint64_t>(channel.m_talker), index)) {
this->m_callback->RemotePlayerTalkNotifyStop(player, channel.m_talker, channel.m_session);
}
}
}
for (int32_t c = 0; c < channelCount; c++) {
TalkingTalkerInfo& channel = localPlayer->m_channels[c];
channel.m_talker = infos[c].m_talker;
channel.m_session = infos[c].m_session;
channel.m_active = infos[c].m_active;
if (infos[c].m_active) {
channel.m_holdFrames = this->m_holdFrames;
}
}
for (int32_t c = 0; c < channelCount; c++) {
TalkingTalkerInfo& info = infos[c];
if (!info.m_talker) {
continue;
}
if (!info.m_active) {
RemoteTalker* remote;
if (this->m_remoteTalkers.Get(ComSat::MapKey<uint64_t>(info.m_talker), remote)) {
double rate = ComSat::Sound::CODECIPMR6000::s_samplesPerFrame * 1000.0f / ComSat::Sound::CODECIPMR6000::s_sampleRate / remote->m_frameTime.GetCurrentAverage();
this->GenerateAndWriteSilenceToHeadsetDeviceBuffer(player, c, 1.0f, rate);
}
continue;
}
double buffered = 0.0;
if (this->m_io) {
int32_t blockSize = this->m_io->GetPlaybackBlockSize(player);
if (blockSize) {
buffered = this->m_io->GetRemainingPlaybackBytes(player, c) / blockSize;
}
}
if (info.m_active && info.m_talker) {
uint32_t elapsed = this->m_currentTime - this->m_startTime;
double missing = frames - elapsed * 0.001 * this->m_framesPerSecond - buffered;
if (missing >= 1.0 && 0.0 == buffered) {
this->GenerateAndWriteSilenceToHeadsetDeviceBuffer(player, c, static_cast<float>(missing), 1.0);
}
}
RemoteTalker* remote;
if (!this->m_remoteTalkers.Get(ComSat::MapKey<uint64_t>(info.m_talker), remote)) {
continue;
}
float sessionVolume;
if (!localPlayer->m_sessionVolumes.Get(ComSat::MapKey<uint64_t>(info.m_session), sessionVolume)) {
sessionVolume = 1.0f;
}
float talkerVolume;
if (!localPlayer->m_talkerVolumes.Get(ComSat::MapKey<uint64_t>(info.m_talker), talkerVolume)) {
talkerVolume = 1.0f;
}
this->m_io->SetPlayerPlaybackVolume(player, c, talkerVolume * sessionVolume);
double average = remote->m_frameTime.GetCurrentAverage();
int32_t slot = static_cast<int32_t>(remote->m_playCursor);
double rate = ComSat::Sound::CODECIPMR6000::s_samplesPerFrame * 1000.0f / ComSat::Sound::CODECIPMR6000::s_sampleRate / average;
int32_t end = static_cast<int32_t>(remote->m_playCursor + rate) % s_jitterBufferSize;
for (; slot != end; slot = (slot + 1) % s_jitterBufferSize) {
VoicePacket* packet = &remote->m_packets[slot];
if (!packet->m_valid) {
this->GenerateAndWriteSilenceToHeadsetDeviceBuffer(player, c, 1.0f, rate);
continue;
}
uint32_t sequence = packet->m_sequence;
if (sequence < remote->m_lastResetSequence) {
sequence += 0x10000;
}
if ((sequence - remote->m_lastResetSequence >= static_cast<uint32_t>(ComSat::Sound::CODEC::MinimumSafeFramesBetweenResets()) && ComSat::Sound::CODEC::MinimumSafeFramesBetweenResets() && !(packet->m_sequence % ComSat::Sound::CODEC::MinimumSafeFramesBetweenResets())) || reset) {
this->m_codec->ResetPlayerChannelDecoder(player, c);
remote->m_lastResetSequence = packet->m_sequence;
reset = false;
}
uint32_t size;
this->DecodeVoicePacket(player, c, packet, &size);
LocalPlayer* target;
if (this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), target)) {
this->m_codec->ApplyVoiceEffects(player, target->m_buffer, &size);
}
this->WriteVoiceDataToHeadsetDeviceBuffer(player, c, size, rate);
}
}
}
// VERIFY: 38d75a44 auto
// OFFSET: 0x00884850
void ComSat::Sound::Manager::EncodeAvailableVoiceData() {
uint32_t iterator = 0;
ComSat::MapKey<uint8_t> key;
LocalPlayer* localPlayer;
while (this->m_localPlayers.Next(iterator, key, localPlayer)) {
this->EncodeAvailableVoiceDataForLocalPlayer(key.m_value, localPlayer);
}
}
// VERIFY: a25f3ffc manual
// OFFSET: [0x008848B0, 0x00884DA0]
ComSat::Sound::Manager::~Manager() {
uint32_t iterator = 0;
ComSat::MapKey<uint8_t> playerKey;
LocalPlayer* localPlayer;
for (; this->m_localPlayers.Next(iterator, playerKey, localPlayer); iterator = 0) {
LocalPlayer* removed;
this->m_localPlayers.Remove(playerKey, removed);
ComSat::Delete(*this->m_allocator, localPlayer);
}
iterator = 0;
ComSat::MapKey<uint64_t> key;
Session* info;
for (; this->m_sessions.Next(iterator, key, info); iterator = 0) {
Session* removed;
this->m_sessions.Remove(key, removed);
ComSat::Delete(*this->m_allocator, info);
}
this->m_sessions.Clear();
iterator = 0;
RemoteTalker* remote;
for (; this->m_remoteTalkers.Next(iterator, key, remote); iterator = 0) {
RemoteTalker* removed;
this->m_remoteTalkers.Remove(key, removed);
ComSat::Delete(*this->m_allocator, remote);
}
if (this->m_io) {
ComSat::Delete(*this->m_allocator, this->m_io);
}
if (this->m_codec) {
ComSat::Delete(*this->m_allocator, this->m_codec);
}
}
// VERIFY: 8880502e manual
// OFFSET: 0x00884AB0
bool ComSat::Sound::Manager::UnregisterRemoteTalkerFromSession(uint64_t session, uint64_t talker) {
Session* info;
if (!this->m_sessions.Get(ComSat::MapKey<uint64_t>(session), info)) {
return false;
}
RemoteTalker* remote;
if (!this->m_remoteTalkers.Get(ComSat::MapKey<uint64_t>(talker), remote)) {
return false;
}
uint8_t priority;
info->m_talkerPriorities.Remove(ComSat::MapKey<uint64_t>(talker), priority);
uint32_t iterator = 0;
ComSat::MapKey<uint64_t> key(0);
Session* other;
while (this->m_sessions.Next(iterator, key, other)) {
if (key.m_value != session) {
uint32_t index;
if (other->m_talkerPriorities.Find(ComSat::MapKey<uint64_t>(talker), index)) {
return true;
}
}
}
RemoteTalker* removed;
this->m_remoteTalkers.Remove(ComSat::MapKey<uint64_t>(talker), removed);
ComSat::Delete(*this->m_allocator, remote);
return true;
}
// VERIFY: 3e78c7de manual
// OFFSET: 0x00884CA0
void ComSat::Sound::Manager::PlayScheduledVoiceData() {
uint32_t elapsed = this->m_currentTime - this->m_startTime;
double frames = elapsed * 0.001 * this->m_framesPerSecond;
int32_t frame = static_cast<int32_t>(frames + 1.0);
int32_t count = static_cast<int32_t>(this->m_jitterDelay - this->m_currentFrame + frames);
if (count > this->m_jitterDelay) {
count = this->m_jitterDelay;
}
frame += this->m_jitterDelay - count;
for (; count > 0; count--) {
uint32_t iterator = 0;
ComSat::MapKey<uint8_t> playerKey;
LocalPlayer* localPlayer;
while (this->m_localPlayers.Next(iterator, playerKey, localPlayer)) {
this->PlayVoiceDataForLocalPlayer(playerKey.m_value, frame);
}
iterator = 0;
ComSat::MapKey<uint64_t> key;
RemoteTalker* remote;
while (this->m_remoteTalkers.Next(iterator, key, remote)) {
this->AdvancePlayCursorForRemoteTalker(remote);
}
this->m_currentFrame = frame++;
}
}
// VERIFY: ef10a638 auto
// OFFSET: 0x00884DB0
void ComSat::Sound::Manager::Work(uint32_t time) {
this->m_currentTime = time;
if (this->m_io) {
this->m_io->Work(time);
}
this->PlayScheduledVoiceData();
this->EncodeAvailableVoiceData();
}
// VERIFY: 28a13445 manual
// OFFSET: 0x00884DE0
bool ComSat::Sound::Manager::SessionDestroy(uint64_t session) {
Session* info;
if (this->m_sessions.Get(ComSat::MapKey<uint64_t>(session), info)) {
uint32_t iterator = 0;
ComSat::MapKey<uint64_t> key(0);
uint8_t priority;
while (info->m_talkerPriorities.Next(iterator, key, priority)) {
this->UnregisterRemoteTalkerFromSession(session, key.m_value);
}
if (this->m_sessions.Remove(ComSat::MapKey<uint64_t>(session), info)) {
ComSat::Delete(*this->m_allocator, info);
}
}
return true;
}
// VERIFY: a1c02a9e manual
// OFFSET: 0x00884F10
bool ComSat::Sound::Manager::UnregisterLocalTalkerFromSession(uint64_t session, uint8_t player) {
LocalPlayer* localPlayer;
if (!this->m_localPlayers.Get(ComSat::MapKey<uint8_t>(player), localPlayer)) {
return false;
}
uint32_t index;
if (!this->m_sessions.Find(ComSat::MapKey<uint64_t>(session), index)) {
return false;
}
localPlayer->m_mutedSessions.Remove(session);
uint8_t priority;
localPlayer->m_sessionPriorities.Remove(ComSat::MapKey<uint64_t>(session), priority);
float volume;
localPlayer->m_sessionVolumes.Remove(ComSat::MapKey<uint64_t>(session), volume);
LocalPlayer* other = nullptr;
ComSat::MapKey<uint8_t> key(0);
uint32_t iterator = 0;
bool last = true;
while (this->m_localPlayers.Next(iterator, key, other)) {
if (player != key.m_value && other->m_sessionPriorities.Find(ComSat::MapKey<uint64_t>(session), index)) {
last = false;
}
}
if (last) {
this->SessionDestroy(session);
}
return true;
}
// VERIFY: 717e19dc auto
// OFFSET: 0x008850F0
bool ComSat::Sound::Manager::DestroyLocalPlayer(uint8_t player) {
uint32_t iterator = 0;
ComSat::MapKey<uint64_t> key;
Session* info;
while (this->m_sessions.Next(iterator, key, info)) {
this->UnregisterLocalTalkerFromSession(key.m_value, player);
}
LocalPlayer* localPlayer;
if (this->m_localPlayers.Remove(ComSat::MapKey<uint8_t>(player), localPlayer)) {
ComSat::Delete(*this->m_allocator, localPlayer);
if (this->m_io) {
this->m_io->DestroyLocalPlayer(player);
}
if (this->m_codec) {
this->m_codec->RemoveLocalPlayer(player);
}
}
return true;
}