mirror of
https://github.com/danog/libtgvoip.git
synced 2024-11-30 04:39:03 +01:00
278 lines
8.7 KiB
C++
278 lines
8.7 KiB
C++
//
|
|
// Created by Grishka on 25/02/2019.
|
|
//
|
|
|
|
#include <algorithm>
|
|
#include <math.h>
|
|
#include "ScreamCongestionController.h"
|
|
#include "../tools/logging.h"
|
|
#include "../VoIPController.h"
|
|
|
|
using namespace tgvoip;
|
|
using namespace tgvoip::video;
|
|
|
|
namespace{
|
|
constexpr float QDELAY_TARGET_LO=0.1f; // seconds
|
|
constexpr float QDELAY_TARGET_HI=0.4f; // seconds
|
|
constexpr float QDELAY_WEIGHT=0.1f;
|
|
constexpr float QDELAY_TREND_TH=0.2f;
|
|
constexpr uint32_t MIN_CWND=3000; // bytes
|
|
constexpr float MAX_BYTES_IN_FLIGHT_HEAD_ROOM=1.1f;
|
|
constexpr float GAIN=1.0f;
|
|
constexpr float BETA_LOSS=0.9f;
|
|
constexpr float BETA_ECN=0.9f;
|
|
constexpr float BETA_R=0.9f;
|
|
constexpr uint32_t MSS=1024;
|
|
constexpr float RATE_ADJUST_INTERVAL=0.2f;
|
|
constexpr uint32_t TARGET_BITRATE_MIN=50*1024; // bps
|
|
constexpr uint32_t TARGET_BITRATE_MAX=500*1024; // bps
|
|
constexpr uint32_t RAMP_UP_SPEED=1024*1024;//200000; // bps/s
|
|
constexpr float PRE_CONGESTION_GUARD=0.1f;
|
|
constexpr float TX_QUEUE_SIZE_FACTOR=1.0f;
|
|
constexpr float RTP_QDELAY_TH=0.02f; // seconds
|
|
constexpr float TARGET_RATE_SCALE_RTP_QDELAY=0.95f;
|
|
constexpr float QDELAY_TREND_LO=0.2f;
|
|
constexpr float T_RESUME_FAST_INCREASE=5.0f; // seconds
|
|
constexpr uint32_t RATE_PACE_MIN=50000; // bps
|
|
}
|
|
|
|
ScreamCongestionController::ScreamCongestionController() : qdelayTarget(QDELAY_TARGET_LO), cwnd(MIN_CWND) {
|
|
|
|
}
|
|
|
|
void ScreamCongestionController::UpdateVariables(float qdelay){
|
|
float qdelayFraction=qdelay/qdelayTarget;
|
|
qdelayFractionAvg=(1.0f-QDELAY_WEIGHT)*qdelayFractionAvg+qdelayFraction*QDELAY_WEIGHT;
|
|
qdelayFractionHist.Add(qdelayFraction);
|
|
float avg=qdelayFractionHist.Average();
|
|
|
|
float r1=0.0, r0=0.0;
|
|
for(int i=(int)qdelayFractionHist.Size()-1;i>=0;i--){
|
|
float v=qdelayFractionHist[i]-avg;
|
|
r0+=v*v;
|
|
}
|
|
for(int i=(int)qdelayFractionHist.Size()-1;i>=1;i--){
|
|
float v1=qdelayFractionHist[i]-avg;
|
|
float v2=qdelayFractionHist[i-1]-avg;
|
|
r1+=v1*v2;
|
|
}
|
|
float a=r1/r0;
|
|
qdelayTrend=std::min(1.0f, std::max(0.0f, a*qdelayFractionAvg));
|
|
qdelayTrendMem=std::max(0.99f*qdelayTrendMem, qdelayTrend);
|
|
|
|
if(qdelayTrend>QDELAY_TREND_LO){
|
|
lastTimeQDelayTrendWasGreaterThanLo=VoIPController::GetCurrentTime();
|
|
}
|
|
}
|
|
|
|
void ScreamCongestionController::UpdateCWnd(float qdelay){
|
|
if(inFastIncrease){
|
|
if(qdelayTrend>=QDELAY_TREND_TH){
|
|
inFastIncrease=false;
|
|
}else{
|
|
if((float)bytesInFlight*1.5f+bytesNewlyAcked>cwnd){
|
|
//LOGD("HERE");
|
|
cwnd+=bytesNewlyAcked;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
float offTarget=(qdelayTarget-qdelay)/qdelayTarget;
|
|
|
|
float gain=GAIN;
|
|
float cwndDelta=gain*offTarget*bytesNewlyAcked*MSS/(float)cwnd;
|
|
if(offTarget>0 && (float)bytesInFlight*1.25f+bytesNewlyAcked<=cwnd){
|
|
cwndDelta=0.0;
|
|
}
|
|
cwnd+=cwndDelta;
|
|
cwnd=std::min(cwnd, (uint32_t)(maxBytesInFlight*MAX_BYTES_IN_FLIGHT_HEAD_ROOM));
|
|
cwnd=std::max(cwnd, MIN_CWND);
|
|
}
|
|
|
|
void ScreamCongestionController::AdjustQDelayTarget(float qdelay){
|
|
float qdelayNorm=qdelay/QDELAY_TARGET_LO;
|
|
qdelayNormHist.Add(qdelayNorm);
|
|
|
|
float qdelayNormAvg=qdelayNormHist.Average();
|
|
float qdelayNormVar=0.0;
|
|
for(uint32_t i=0;i<qdelayNormHist.Size();i++){
|
|
float tmp=qdelayNormHist[i]-qdelayNormAvg;
|
|
qdelayNormVar+=tmp*tmp;
|
|
}
|
|
qdelayNormVar/=qdelayNormHist.Size();
|
|
|
|
float newTarget=qdelayNormAvg+sqrt(qdelayNormVar);
|
|
newTarget*=QDELAY_TARGET_LO;
|
|
|
|
if(lossEventRate>0.002f){
|
|
qdelayTarget=1.5f*newTarget;
|
|
}else{
|
|
if(qdelayNormVar<0.2f){
|
|
qdelayTarget=newTarget;
|
|
}else{
|
|
if(newTarget<QDELAY_TARGET_LO){
|
|
qdelayTarget=std::max(qdelayTarget*0.5f, newTarget);
|
|
}else{
|
|
qdelayTarget*=0.9;
|
|
}
|
|
}
|
|
}
|
|
|
|
qdelayTarget=std::min(QDELAY_TARGET_HI, qdelayTarget);
|
|
qdelayTarget=std::max(QDELAY_TARGET_LO, qdelayTarget);
|
|
}
|
|
|
|
void ScreamCongestionController::AdjustBitrate(){
|
|
if(lossPending){
|
|
lossPending=false;
|
|
targetBitrate=std::max((uint32_t)(BETA_R*(float)targetBitrate), TARGET_BITRATE_MIN);
|
|
return;
|
|
}
|
|
|
|
float rampUpSpeed=std::min(RAMP_UP_SPEED, targetBitrate/2);
|
|
float scale=(float)(targetBitrate-targetBitrateLastMax)/(float)targetBitrateLastMax;
|
|
scale=std::max(0.2f, std::min(1.0f, (scale*4)*(scale*4)));
|
|
float currentRate=std::max(rateTransmit, rateAck);
|
|
|
|
if(inFastIncrease){
|
|
float increment=(rampUpSpeed*RATE_ADJUST_INTERVAL)*scale;
|
|
targetBitrate+=increment;
|
|
}else{
|
|
float deltaRate=currentRate*(1.0f-PRE_CONGESTION_GUARD*qdelayTrend)-TX_QUEUE_SIZE_FACTOR*(float)rtpQueueSize;
|
|
if(deltaRate>0.0f){
|
|
deltaRate*=scale;
|
|
deltaRate=std::min(deltaRate, rampUpSpeed*RATE_ADJUST_INTERVAL);
|
|
}
|
|
targetBitrate+=deltaRate;
|
|
float rtpQueueDelay=(float)rtpQueueSize/currentRate;
|
|
if(rtpQueueDelay>RTP_QDELAY_TH){
|
|
targetBitrate=(uint32_t)((float)targetBitrate*TARGET_RATE_SCALE_RTP_QDELAY);
|
|
}
|
|
}
|
|
|
|
float rateMediaLimit=std::max(currentRate, std::max(rateMedia, rateMediaMedian));
|
|
rateMediaLimit*=(2.0-qdelayTrendMem);
|
|
targetBitrate=std::min(targetBitrate, (uint32_t)rateMediaLimit);
|
|
targetBitrate=std::min(TARGET_BITRATE_MAX, std::max(TARGET_BITRATE_MIN, targetBitrate));
|
|
}
|
|
|
|
void ScreamCongestionController::CalculateSendWindow(float qdelay){
|
|
if(qdelay<=qdelayTarget)
|
|
sendWnd=cwnd+MSS-bytesInFlight;
|
|
else
|
|
sendWnd=cwnd-bytesInFlight;
|
|
}
|
|
|
|
void ScreamCongestionController::ProcessAcks(float oneWayDelay, uint32_t bytesNewlyAcked, uint32_t lossCount, double rtt){
|
|
if(prevOneWayDelay!=0.0f){
|
|
double currentTime=VoIPController::GetCurrentTime();
|
|
float qdelay=oneWayDelay-prevOneWayDelay;
|
|
sRTT=(float)rtt;
|
|
bytesInFlight-=bytesNewlyAcked;
|
|
rtpQueueSize-=(bytesNewlyAcked*8);
|
|
UpdateBytesInFlightHistory();
|
|
bytesAcked+=bytesNewlyAcked;
|
|
//LOGV("Scream: qdelay = %f, newly acked = %u, in flight = %u, losses = %u", qdelay, bytesNewlyAcked, bytesInFlight, lossCount);
|
|
if(currentTime-lastVariablesUpdateTime>=0.050){
|
|
lastVariablesUpdateTime=currentTime;
|
|
UpdateVariables(qdelay);
|
|
}
|
|
if(currentTime-lastRateAdjustmentTime>=RATE_ADJUST_INTERVAL){
|
|
lastRateAdjustmentTime=currentTime;
|
|
AdjustBitrate();
|
|
//LOGV("Scream: target bitrate = %u", targetBitrate);
|
|
}
|
|
if(lossCount>prevLossCount && currentTime>ignoreLossesUntil){
|
|
LOGD("Scream: loss detected");
|
|
ignoreLossesUntil=currentTime+rtt;
|
|
LOGD("ignoring losses for %f", rtt);
|
|
inFastIncrease=false;
|
|
cwnd=std::max(MIN_CWND, (uint32_t)(cwnd*BETA_LOSS));
|
|
AdjustQDelayTarget(qdelay);
|
|
CalculateSendWindow(qdelay);
|
|
lossPending=true;
|
|
lastTimeQDelayTrendWasGreaterThanLo=currentTime;
|
|
}else{
|
|
this->bytesNewlyAcked+=bytesNewlyAcked;
|
|
if(currentTime-lastCWndUpdateTime>=0.15){
|
|
lastCWndUpdateTime=currentTime;
|
|
UpdateCWnd(qdelay);
|
|
//LOGI("Scream: cwnd = %u", cwnd);
|
|
this->bytesNewlyAcked=0;
|
|
}
|
|
AdjustQDelayTarget(qdelay);
|
|
CalculateSendWindow(qdelay);
|
|
if(!inFastIncrease){
|
|
if(currentTime-lastTimeQDelayTrendWasGreaterThanLo>=T_RESUME_FAST_INCREASE){
|
|
inFastIncrease=true;
|
|
}
|
|
}
|
|
}
|
|
prevLossCount=lossCount;
|
|
}
|
|
prevOneWayDelay=oneWayDelay;
|
|
}
|
|
|
|
void ScreamCongestionController::ProcessPacketSent(uint32_t size){
|
|
bytesInFlight+=size;
|
|
rtpQueueSize+=(size*8);
|
|
bytesSent+=size;
|
|
double currentTime=VoIPController::GetCurrentTime();
|
|
if(currentTime-rateTransmitUpdateTime>=0.2){
|
|
rateTransmit=(float)(bytesSent*8)/(float)(currentTime-rateTransmitUpdateTime);
|
|
rateAck=(float)(bytesAcked*8)/(float)(currentTime-rateTransmitUpdateTime);
|
|
rateTransmitUpdateTime=currentTime;
|
|
bytesSent=0;
|
|
bytesAcked=0;
|
|
//LOGV("rateTransmit %f, rateAck %f", rateTransmit, rateAck);
|
|
}
|
|
UpdateBytesInFlightHistory();
|
|
}
|
|
|
|
void ScreamCongestionController::ProcessPacketLost(uint32_t size){
|
|
bytesInFlight-=size;
|
|
rtpQueueSize-=(size*8);
|
|
UpdateBytesInFlightHistory();
|
|
}
|
|
|
|
double ScreamCongestionController::GetPacingInterval(){
|
|
float paceBitrate=std::max((float)RATE_PACE_MIN, cwnd*8.0f/sRTT);
|
|
//LOGV("RTT=%f cwnd=%u paceBitrate=%f fastIncrease=%d", sRTT, cwnd, paceBitrate, inFastIncrease);
|
|
double pacingInterval=rtpSize*8.0f/paceBitrate;
|
|
return std::min(0.010, pacingInterval);
|
|
}
|
|
|
|
void ScreamCongestionController::UpdateBytesInFlightHistory(){
|
|
double currentTime=VoIPController::GetCurrentTime();
|
|
ValueSample now={bytesInFlight, currentTime};
|
|
bytesInFlightHistory.push_back(now);
|
|
uint32_t max=0;
|
|
for(std::vector<ValueSample>::iterator i=bytesInFlightHistory.begin();i!=bytesInFlightHistory.end();){
|
|
if(currentTime-i->time>=5.0){
|
|
i=bytesInFlightHistory.erase(i);
|
|
}else{
|
|
max=std::max(max, i->sample);
|
|
++i;
|
|
}
|
|
}
|
|
maxBytesInFlight=max;
|
|
}
|
|
|
|
void ScreamCongestionController::UpdateMediaRate(uint32_t frameSize){
|
|
bytesMedia+=frameSize;
|
|
double currentTime=VoIPController::GetCurrentTime();
|
|
if(currentTime-rateMediaUpdateTime>=0.5){
|
|
rateMedia=(float)(bytesMedia*8)/(float)(currentTime-rateMediaUpdateTime);
|
|
bytesMedia=0;
|
|
rateMediaUpdateTime=currentTime;
|
|
LOGV("rateMedia %f", rateMedia);
|
|
rateMediaHistory.Add(rateMedia);
|
|
rateMediaMedian=rateMediaHistory.NonZeroAverage();
|
|
}
|
|
}
|
|
|
|
uint32_t ScreamCongestionController::GetBitrate(){
|
|
return targetBitrate;
|
|
}
|