1
0
mirror of https://github.com/danog/libtgvoip.git synced 2024-11-26 20:24:38 +01:00
libtgvoip/VoIPGroupController.cpp
2020-01-28 23:45:47 +01:00

633 lines
20 KiB
C++

//
// libtgvoip is free and unencumbered public domain software.
// For more information, see http://unlicense.org or the UNLICENSE file
// you should have received with this source code distribution.
//
#include "VoIPGroupController.h"
#include "controller/net/PacketSender.h"
#include "tools/logging.h"
#include "VoIPServerConfig.h"
#include "controller/PrivateDefines.h"
#include <assert.h>
#include <math.h>
#include <time.h>
using namespace tgvoip;
using namespace std;
VoIPGroupController::VoIPGroupController(int32_t timeDifference)
{
userSelfID = 0;
this->timeDifference = timeDifference;
LOGV("Created VoIPGroupController; timeDifference=%d", timeDifference);
}
VoIPGroupController::~VoIPGroupController()
{
if (audioOutput)
{
audioOutput->Stop();
}
LOGD("before stop audio mixer");
audioMixer.Stop();
}
void VoIPGroupController::SetGroupCallInfo(unsigned char *encryptionKey, unsigned char *reflectorGroupTag, unsigned char *reflectorSelfTag, unsigned char *reflectorSelfSecret, unsigned char *reflectorSelfTagHash, int32_t selfUserID, NetworkAddress reflectorAddress, NetworkAddress reflectorAddressV6, uint16_t reflectorPort)
{
Endpoint e;
e.address = reflectorAddress;
e.v6address = reflectorAddressV6;
e.port = reflectorPort;
memcpy(e.peerTag, reflectorGroupTag, 16);
e.type = Endpoint::Type::UDP_RELAY;
e.id = FOURCC('G', 'R', 'P', 'R');
endpoints[e.id] = e;
groupReflector = e;
currentEndpoint = e.id;
memcpy(this->encryptionKey, encryptionKey, 256);
memcpy(this->reflectorSelfTag, reflectorSelfTag, 16);
memcpy(this->reflectorSelfSecret, reflectorSelfSecret, 16);
memcpy(this->reflectorSelfTagHash, reflectorSelfTagHash, 16);
uint8_t sha256[SHA256_LENGTH];
crypto.sha256((uint8_t *)encryptionKey, 256, sha256);
memcpy(callID, sha256 + (SHA256_LENGTH - 16), 16);
memcpy(keyFingerprint, sha256 + (SHA256_LENGTH - 16), 8);
this->userSelfID = selfUserID;
//LOGD("reflectorSelfTag = %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", reflectorSelfTag[0], reflectorSelfTag[1], reflectorSelfTag[2], reflectorSelfTag[3], reflectorSelfTag[4], reflectorSelfTag[5], reflectorSelfTag[6], reflectorSelfTag[7], reflectorSelfTag[8], reflectorSelfTag[9], reflectorSelfTag[10], reflectorSelfTag[11], reflectorSelfTag[12], reflectorSelfTag[13], reflectorSelfTag[14], reflectorSelfTag[15]);
//LOGD("reflectorSelfSecret = %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", reflectorSelfSecret[0], reflectorSelfSecret[1], reflectorSelfSecret[2], reflectorSelfSecret[3], reflectorSelfSecret[4], reflectorSelfSecret[5], reflectorSelfSecret[6], reflectorSelfSecret[7], reflectorSelfSecret[8], reflectorSelfSecret[9], reflectorSelfSecret[10], reflectorSelfSecret[11], reflectorSelfSecret[12], reflectorSelfSecret[13], reflectorSelfSecret[14], reflectorSelfSecret[15]);
//LOGD("reflectorSelfTagHash = %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", reflectorSelfTagHash[0], reflectorSelfTagHash[1], reflectorSelfTagHash[2], reflectorSelfTagHash[3], reflectorSelfTagHash[4], reflectorSelfTagHash[5], reflectorSelfTagHash[6], reflectorSelfTagHash[7], reflectorSelfTagHash[8], reflectorSelfTagHash[9], reflectorSelfTagHash[10], reflectorSelfTagHash[11], reflectorSelfTagHash[12], reflectorSelfTagHash[13], reflectorSelfTagHash[14], reflectorSelfTagHash[15]);
}
void VoIPGroupController::AddGroupCallParticipant(int32_t userID, unsigned char *memberTagHash, unsigned char *serializedStreams, size_t streamsLength)
{
if (userID == userSelfID)
return;
if (userSelfID == 0)
return;
//if(streamsLength==0)
// return;
MutexGuard m(participantsMutex);
LOGV("Adding group call user %d, streams length %u", userID, (unsigned int)streamsLength);
for (vector<GroupCallParticipant>::iterator p = participants.begin(); p != participants.end(); ++p)
{
if (p->userID == userID)
{
LOGE("user %d already added", userID);
abort();
break;
}
}
GroupCallParticipant p;
p.userID = userID;
memcpy(p.memberTagHash, memberTagHash, sizeof(p.memberTagHash));
BufferInputStream ss(serializedStreams, streamsLength);
vector<shared_ptr<Stream>> streams = DeserializeStreams(ss);
unsigned char audioStreamID = 0;
for (vector<shared_ptr<Stream>>::iterator _s = streams.begin(); _s != streams.end(); ++_s)
{
shared_ptr<Stream> &s = *_s;
s->userID = userID;
if (s->type == STREAM_TYPE_AUDIO && s->codec == CODEC_OPUS && !audioStreamID)
{
audioStreamID = s->id;
s->jitterBuffer = make_shared<JitterBuffer>(s->frameDuration);
if (s->frameDuration > 50)
s->jitterBuffer->SetMinPacketCount((uint32_t)ServerConfig::GetSharedInstance()->GetInt("jitter_initial_delay_60", 2));
else if (s->frameDuration > 30)
s->jitterBuffer->SetMinPacketCount((uint32_t)ServerConfig::GetSharedInstance()->GetInt("jitter_initial_delay_40", 4));
else
s->jitterBuffer->SetMinPacketCount((uint32_t)ServerConfig::GetSharedInstance()->GetInt("jitter_initial_delay_20", 6));
s->callbackWrapper = make_shared<CallbackWrapper>();
s->decoder = make_shared<OpusDecoder>(s->callbackWrapper, false, false);
s->decoder->SetJitterBuffer(s->jitterBuffer);
s->decoder->SetFrameDuration(s->frameDuration);
s->decoder->SetDTX(true);
s->decoder->SetLevelMeter(p.levelMeter);
audioMixer.AddInput(s->callbackWrapper);
}
incomingStreams.push_back(s);
}
if (!audioStreamID)
{
LOGW("User %d has no usable audio stream", userID);
}
p.streams.insert(p.streams.end(), streams.begin(), streams.end());
participants.push_back(p);
LOGI("Added group call participant %d", userID);
}
void VoIPGroupController::RemoveGroupCallParticipant(int32_t userID)
{
MutexGuard m(participantsMutex);
vector<shared_ptr<Stream>>::iterator stm = incomingStreams.begin();
while (stm != incomingStreams.end())
{
if ((*stm)->userID == userID)
{
LOGI("Removed stream %d belonging to user %d", (*stm)->id, userID);
audioMixer.RemoveInput((*stm)->callbackWrapper);
(*stm)->decoder->Stop();
stm = incomingStreams.erase(stm);
continue;
}
++stm;
}
for (vector<GroupCallParticipant>::iterator p = participants.begin(); p != participants.end(); ++p)
{
if (p->userID == userID)
{
participants.erase(p);
LOGI("Removed group call participant %d", userID);
break;
}
}
}
vector<shared_ptr<VoIPController::Stream>> VoIPGroupController::DeserializeStreams(BufferInputStream &in)
{
vector<shared_ptr<Stream>> res;
try
{
unsigned char count = in.ReadByte();
for (unsigned char i = 0; i < count; i++)
{
uint16_t len = (uint16_t)in.ReadInt16();
BufferInputStream inner = in.GetPartBuffer(len, true);
shared_ptr<Stream> s = make_shared<Stream>();
s->id = inner.ReadByte();
s->type = static_cast<StreamType>(inner.ReadByte());
s->codec = (uint32_t)inner.ReadInt32();
uint32_t flags = (uint32_t)inner.ReadInt32();
s->enabled = (flags & STREAM_FLAG_ENABLED) == STREAM_FLAG_ENABLED;
s->frameDuration = (uint16_t)inner.ReadInt16();
res.push_back(s);
}
}
catch (out_of_range &x)
{
LOGW("Error deserializing streams: %s", x.what());
}
return res;
}
void VoIPGroupController::SetParticipantStreams(int32_t userID, unsigned char *serializedStreams, size_t length)
{
LOGD("Set participant streams for %d", userID);
MutexGuard m(participantsMutex);
for (vector<GroupCallParticipant>::iterator p = participants.begin(); p != participants.end(); ++p)
{
if (p->userID == userID)
{
BufferInputStream in(serializedStreams, length);
vector<shared_ptr<Stream>> streams = DeserializeStreams(in);
for (vector<shared_ptr<Stream>>::iterator ns = streams.begin(); ns != streams.end(); ++ns)
{
bool found = false;
for (vector<shared_ptr<Stream>>::iterator s = p->streams.begin(); s != p->streams.end(); ++s)
{
if ((*s)->id == (*ns)->id)
{
(*s)->enabled = (*ns)->enabled;
if (groupCallbacks.participantAudioStateChanged)
groupCallbacks.participantAudioStateChanged(this, userID, (*s)->enabled);
found = true;
break;
}
}
if (!found)
{
LOGW("Tried to add stream %d for user %d but adding/removing streams is not supported", (*ns)->id, userID);
}
}
break;
}
}
}
size_t VoIPGroupController::GetInitialStreams(unsigned char *buf, size_t size)
{
BufferOutputStream s(buf, size);
s.WriteByte(1); // streams count
s.WriteInt16(12); // this object length
s.WriteByte(1); // stream id
s.WriteByte(STREAM_TYPE_AUDIO);
s.WriteInt32(CODEC_OPUS);
s.WriteInt32(STREAM_FLAG_ENABLED | STREAM_FLAG_DTX); // flags
s.WriteInt16(60); // frame duration
return s.GetLength();
}
void VoIPGroupController::SendInit()
{
SendRecentPacketsRequest();
}
void VoIPGroupController::ProcessIncomingPacket(NetworkPacket &packet, Endpoint &srcEndpoint)
{
}
void VoIPGroupController::SendUdpPing(Endpoint &endpoint)
{
}
void VoIPGroupController::SetNetworkType(int type)
{
networkType = type;
UpdateDataSavingState();
UpdateAudioBitrateLimit();
string itfName = udpSocket->GetLocalInterfaceInfo(NULL, NULL);
if (itfName != activeNetItfName)
{
udpSocket->OnActiveInterfaceChanged();
LOGI("Active network interface changed: %s -> %s", activeNetItfName.c_str(), itfName.c_str());
bool isFirstChange = activeNetItfName.length() == 0;
activeNetItfName = itfName;
if (isFirstChange)
return;
udpConnectivityState = UDP_UNKNOWN;
udpPingCount = 0;
lastUdpPingTime = 0;
if (proxyProtocol == PROXY_SOCKS5)
InitUDPProxy();
selectCanceller->CancelSelect();
}
}
void VoIPGroupController::SendRecentPacketsRequest()
{
BufferOutputStream out(1024);
out.WriteInt32(TLID_UDP_REFLECTOR_REQUEST_PACKETS_INFO); // TL function
out.WriteInt32(GetCurrentUnixtime()); // date:int
out.WriteInt64(0); // query_id:long
out.WriteInt32(64); // recv_num:int
out.WriteInt32(0); // sent_num:int
SendSpecialReflectorRequest(out.GetBuffer(), out.GetLength());
}
void VoIPGroupController::SendSpecialReflectorRequest(unsigned char *data, size_t len)
{
/*BufferOutputStream out(1024);
unsigned char buf[1500];
crypto.rand_bytes(buf, 8);
out.WriteBytes(buf, 8);
out.WriteInt32((int32_t)len);
out.WriteBytes(data, len);
if(out.GetLength()%16!=0){
size_t paddingLen=16-(out.GetLength()%16);
crypto.rand_bytes(buf, paddingLen);
out.WriteBytes(buf, paddingLen);
}
unsigned char iv[16];
crypto.rand_bytes(iv, 16);
unsigned char key[32];
crypto.sha256(reflectorSelfSecret, 16, key);
unsigned char _iv[16];
memcpy(_iv, iv, 16);
size_t encryptedLen=out.GetLength();
crypto.aes_cbc_encrypt(out.GetBuffer(), buf, encryptedLen, key, _iv);
out.Reset();
out.WriteBytes(reflectorSelfTag, 16);
out.WriteBytes(iv, 16);
out.WriteBytes(buf, encryptedLen);
out.WriteBytes(reflectorSelfSecret, 16);
crypto.sha256(out.GetBuffer(), out.GetLength(), buf);
out.Rewind(16);
out.WriteBytes(buf, 16);
NetworkPacket pkt={0};
pkt.address=&groupReflector.address;
pkt.port=groupReflector.port;
pkt.protocol=PROTO_UDP;
pkt.data=out.GetBuffer();
pkt.length=out.GetLength();
ActuallySendPacket(pkt, groupReflector);*/
}
void VoIPGroupController::SendRelayPings()
{
//LOGV("Send relay pings 2");
double currentTime = GetCurrentTime();
if (currentTime - groupReflector.lastPingTime >= 0.25)
{
SendRecentPacketsRequest();
groupReflector.lastPingTime = currentTime;
}
}
void VoIPGroupController::OnAudioOutputReady()
{
encoder->SetDTX(true);
audioMixer.SetOutput(audioOutput.get());
audioMixer.SetEchoCanceller(echoCanceller.get());
audioMixer.Start();
audioOutput->Start();
audioOutStarted = true;
encoder->SetLevelMeter(selfLevelMeter);
}
void VoIPGroupController::WritePacketHeader(uint32_t seq, BufferOutputStream *s, unsigned char type, uint32_t length, PacketSender *source)
{
s->WriteInt32(TLID_DECRYPTED_AUDIO_BLOCK);
int64_t randomID;
crypto.rand_bytes((uint8_t *)&randomID, 8);
s->WriteInt64(randomID);
unsigned char randBytes[7];
crypto.rand_bytes(randBytes, 7);
s->WriteByte(7);
s->WriteBytes(randBytes, 7);
uint32_t pflags = PFLAG_HAS_SEQ | PFLAG_HAS_SENDER_TAG_HASH;
if (length > 0)
pflags |= PFLAG_HAS_DATA;
pflags |= ((uint32_t)type) << 24;
s->WriteInt32(pflags);
if (type == PKT_STREAM_DATA || type == PKT_STREAM_DATA_X2 || type == PKT_STREAM_DATA_X3)
{
conctl.PacketSent(seq, length);
}
/*if(pflags & PFLAG_HAS_CALL_ID){
s->WriteBytes(callID, 16);
}*/
//s->WriteInt32(lastRemoteSeq);
s->WriteInt32(seq);
s->WriteBytes(reflectorSelfTagHash, 16);
if (length > 0)
{
if (length <= 253)
{
s->WriteByte((unsigned char)length);
}
else
{
s->WriteByte(254);
s->WriteByte((unsigned char)(length & 0xFF));
s->WriteByte((unsigned char)((length >> 8) & 0xFF));
s->WriteByte((unsigned char)((length >> 16) & 0xFF));
}
}
}
void VoIPGroupController::SendPacket(unsigned char *data, size_t len, Endpoint &ep, PendingOutgoingPacket &srcPacket)
{
if (stopping)
return;
if (ep.type == Endpoint::Type::TCP_RELAY && !useTCP)
return;
BufferOutputStream out(len + 128);
//LOGV("send group packet %u", len);
out.WriteBytes(reflectorSelfTag, 16);
if (len > 0)
{
BufferOutputStream inner(len + 128);
inner.WriteInt32((uint32_t)len);
inner.WriteBytes(data, len);
size_t padLen = 16 - inner.GetLength() % 16;
if (padLen < 12)
padLen += 16;
unsigned char padding[28];
crypto.rand_bytes((uint8_t *)padding, padLen);
inner.WriteBytes(padding, padLen);
assert(inner.GetLength() % 16 == 0);
unsigned char key[32], iv[32], msgKey[16];
out.WriteBytes(keyFingerprint, 8);
BufferOutputStream buf(len + 32);
size_t x = 0;
buf.WriteBytes(encryptionKey + 88 + x, 32);
buf.WriteBytes(inner.GetBuffer() + 4, inner.GetLength() - 4);
unsigned char msgKeyLarge[32];
crypto.sha256(buf.GetBuffer(), buf.GetLength(), msgKeyLarge);
memcpy(msgKey, msgKeyLarge + 8, 16);
KDF2(msgKey, 0, key, iv);
out.WriteBytes(msgKey, 16);
//LOGV("<- MSG KEY: %08x %08x %08x %08x, hashed %u", *reinterpret_cast<int32_t*>(msgKey), *reinterpret_cast<int32_t*>(msgKey+4), *reinterpret_cast<int32_t*>(msgKey+8), *reinterpret_cast<int32_t*>(msgKey+12), inner.GetLength()-4);
unsigned char aesOut[MSC_STACK_FALLBACK(inner.GetLength(), 1500)];
crypto.aes_ige_encrypt(inner.GetBuffer(), aesOut, inner.GetLength(), key, iv);
out.WriteBytes(aesOut, inner.GetLength());
}
// relay signature
out.WriteBytes(reflectorSelfSecret, 16);
unsigned char sig[32];
crypto.sha256(out.GetBuffer(), out.GetLength(), sig);
out.Rewind(16);
out.WriteBytes(sig, 16);
if (srcPacket.type == PKT_STREAM_DATA || srcPacket.type == PKT_STREAM_DATA_X2 || srcPacket.type == PKT_STREAM_DATA_X3)
{
PacketIdMapping mapping = {srcPacket.seq, *reinterpret_cast<uint16_t *>(sig + 14), 0};
MutexGuard m(sentPacketsMutex);
recentSentPackets.push_back(mapping);
//LOGD("sent packet with id: %04X", mapping.id);
while (recentSentPackets.size() > 64)
recentSentPackets.erase(recentSentPackets.begin());
}
packetManager.setLastSentSeq(srcPacket.seq);
if (IS_MOBILE_NETWORK(networkType))
stats.bytesSentMobile += (uint64_t)out.GetLength();
else
stats.bytesSentWifi += (uint64_t)out.GetLength();
/*NetworkPacket pkt={0};
pkt.address=(NetworkAddress*)&ep.address;
pkt.port=ep.port;
pkt.length=out.GetLength();
pkt.data=out.GetBuffer();
pkt.protocol=ep.type==Endpoint::Type::TCP_RELAY ? PROTO_TCP : PROTO_UDP;
ActuallySendPacket(pkt, ep);*/
}
void VoIPGroupController::SetCallbacks(VoIPGroupController::Callbacks callbacks)
{
VoIPController::SetCallbacks(callbacks);
this->groupCallbacks = callbacks;
}
int32_t VoIPGroupController::GetCurrentUnixtime()
{
return time(NULL) + timeDifference;
}
float VoIPGroupController::GetParticipantAudioLevel(int32_t userID)
{
if (userID == userSelfID)
return selfLevelMeter->GetLevel();
MutexGuard m(participantsMutex);
for (vector<GroupCallParticipant>::iterator p = participants.begin(); p != participants.end(); ++p)
{
if (p->userID == userID)
{
return p->levelMeter->GetLevel();
}
}
return 0;
}
void VoIPGroupController::SetMicMute(bool mute)
{
micMuted = mute;
if (audioInput)
{
if (mute)
audioInput->Stop();
else
audioInput->Start();
if (!audioInput->IsInitialized())
{
lastError = ERROR_AUDIO_IO;
SetState(STATE_FAILED);
return;
}
}
outgoingStreams[0]->enabled = !mute;
SerializeAndUpdateOutgoingStreams();
}
void VoIPGroupController::SetParticipantVolume(int32_t userID, float volume)
{
MutexGuard m(participantsMutex);
for (vector<GroupCallParticipant>::iterator p = participants.begin(); p != participants.end(); ++p)
{
if (p->userID == userID)
{
for (vector<shared_ptr<Stream>>::iterator s = p->streams.begin(); s != p->streams.end(); ++s)
{
if ((*s)->type == STREAM_TYPE_AUDIO)
{
if ((*s)->decoder)
{
float db;
if (volume == 0.0f)
db = -INFINITY;
else if (volume < 1.0f)
db = -50.0f * (1.0f - volume);
else if (volume > 1.0f && volume <= 2.0f)
db = 10.0f * (volume - 1.0f);
else
db = 0.0f;
//LOGV("Setting user %u audio volume to %.2f dB", userID, db);
audioMixer.SetInputVolume((*s)->callbackWrapper, db);
}
break;
}
}
break;
}
}
}
void VoIPGroupController::SerializeAndUpdateOutgoingStreams()
{
BufferOutputStream out(1024);
out.WriteByte((unsigned char)outgoingStreams.size());
for (vector<shared_ptr<Stream>>::iterator s = outgoingStreams.begin(); s != outgoingStreams.end(); ++s)
{
BufferOutputStream o(128);
o.WriteByte((*s)->id);
o.WriteByte((*s)->type);
o.WriteInt32((*s)->codec);
o.WriteInt32((unsigned char)(((*s)->enabled ? STREAM_FLAG_ENABLED : 0) | STREAM_FLAG_DTX));
o.WriteInt16((*s)->frameDuration);
out.WriteInt16((int16_t)o.GetLength());
out.WriteBytes(o.GetBuffer(), o.GetLength());
}
if (groupCallbacks.updateStreams)
groupCallbacks.updateStreams(this, out.GetBuffer(), out.GetLength());
}
std::string VoIPGroupController::GetDebugString()
{
std::string r = "Remote endpoints: \n";
char buffer[2048];
for (pair<const int64_t, Endpoint> &_endpoint : endpoints)
{
Endpoint &endpoint = _endpoint.second;
const char *type;
switch (endpoint.type)
{
case Endpoint::Type::UDP_P2P_INET:
type = "UDP_P2P_INET";
break;
case Endpoint::Type::UDP_P2P_LAN:
type = "UDP_P2P_LAN";
break;
case Endpoint::Type::UDP_RELAY:
type = "UDP_RELAY";
break;
case Endpoint::Type::TCP_RELAY:
type = "TCP_RELAY";
break;
default:
type = "UNKNOWN";
break;
}
snprintf(buffer, sizeof(buffer), "%s:%u %dms [%s%s]\n", endpoint.address.ToString().c_str(), endpoint.port, (int)(endpoint.averageRTT * 1000), type, currentEndpoint == endpoint.id ? ", IN_USE" : "");
r += buffer;
}
double avgLate[3];
shared_ptr<JitterBuffer> jitterBuffer = incomingStreams.size() == 1 ? incomingStreams[0]->jitterBuffer : NULL;
if (jitterBuffer)
jitterBuffer->GetAverageLateCount(avgLate);
else
memset(avgLate, 0, 3 * sizeof(double));
snprintf(buffer, sizeof(buffer),
"RTT avg/min: %d/%d\n"
"Congestion window: %d/%d bytes\n"
"Key fingerprint: %02hhX%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX\n"
"Last sent/ack'd seq: %u/%u\n"
"Send/recv losses: %u/%u (%d%%)\n"
"Audio bitrate: %d kbit\n"
"Bytes sent/recvd: %llu/%llu\n\n",
(int)(conctl.GetAverageRTT() * 1000), (int)(conctl.GetMinimumRTT() * 1000),
int(conctl.GetInflightDataSize()), int(conctl.GetCongestionWindow()),
keyFingerprint[0], keyFingerprint[1], keyFingerprint[2], keyFingerprint[3], keyFingerprint[4], keyFingerprint[5], keyFingerprint[6], keyFingerprint[7],
getBestPacketManager().getLastSentSeq(), getBestPacketManager().getLastAckedSeq(),
conctl.GetSendLossCount(), recvLossCount, encoder ? encoder->GetPacketLoss() : 0,
encoder ? (encoder->GetBitrate() / 1000) : 0,
(long long unsigned int)(stats.bytesSentMobile + stats.bytesSentWifi),
(long long unsigned int)(stats.bytesRecvdMobile + stats.bytesRecvdWifi));
MutexGuard m(participantsMutex);
for (vector<GroupCallParticipant>::iterator p = participants.begin(); p != participants.end(); ++p)
{
snprintf(buffer, sizeof(buffer), "Participant id: %d\n", p->userID);
r += buffer;
for (vector<shared_ptr<Stream>>::iterator stm = p->streams.begin(); stm != p->streams.end(); ++stm)
{
char *codec = reinterpret_cast<char *>(&(*stm)->codec);
snprintf(buffer, sizeof(buffer), "Stream %d (type %d, codec '%c%c%c%c', %sabled)\n",
(*stm)->id, (*stm)->type, codec[3], codec[2], codec[1], codec[0], (*stm)->enabled ? "en" : "dis");
r += buffer;
if ((*stm)->enabled)
{
if ((*stm)->jitterBuffer)
{
snprintf(buffer, sizeof(buffer), "Jitter buffer: %d/%.2f\n",
(*stm)->jitterBuffer->GetMinPacketCount(), (*stm)->jitterBuffer->GetAverageDelay());
r += buffer;
}
}
}
r += "\n";
}
return r;
}