The adaptive algorithm of bandwidth in WEBRTC

Transferred from: http://www.xuebuyuan.com/1248366.html

The bandwidth adaptive algorithm in WEBRTC is divided into two types:

1, the originator bandwidth control, the principle is the RTCP in the packet loss statistics to dynamically increase or decrease the bandwidth, in the reduction of bandwidth using the TFRC algorithm to increase the smoothness.

2, the receiver bandwidth estimation, the principle is and by the receipt of RTP data, the estimated bandwidth, with the Kalman filter, the transmission time and reception time of each frame is analyzed, so as to obtain the network bandwidth utilization, revise the estimated bandwidth.

The two algorithms complement each other, and the receiver sends the estimated bandwidth to the originator, which, in combination with the received bandwidth and packet loss rate, adjusts the transmitted bandwidth.

The following is a detailed analysis of two algorithms:

2, receiver-side bandwidth estimation algorithm analysis

Combined with document HTTP://TOOLS.IETF.ORG/HTML/DRAFT-ALVESTRAND-RTCWEB-CONGESTION-02 and source Webrtc/modules/remote_bitrate_ estimator/overuse_detector.cc for analysis

Bandwidth estimation Model: D (i) = DL (i)/C + W (i) d (i) two frame data transmission time difference, DL (i) two frame data size difference, C for network transmission capability, W (i) is our focus, it is mainly determined by three factors: transmission rate, network routing capability, and network transmission Transmission capacity. W (i) conforms to the Gaussian distribution, as a conclusion: when W (i) is increased, it consumes too much bandwidth (over-using), and when W (i) is reduced, consumes less bandwidth (under-using), and for 0 o'clock, the exact bandwidth is used. So, as long as we can calculate w (i), we can determine the current network usage, thereby increasing or reducing the rate of transmission.

Algorithm principle: That is application kalman-filters
Theta_hat (i) = [1/c_hat (i) m_hat (i)]^t//I The State of the time point is represented by C, M, and Theta_hat (i) is the estimated value at this time

Z (i) = d (i)-H_bar (i) ^t * Theta_hat (i-1)//d (i) is the test value, can be easily calculated, the following can be considered as D (i-1) estimates, so Z (i) is the deviation of D (i), that is, the residual

Theta_hat (i) = Theta_hat (i-1) + Z (i) * K_bar (i)///OK, this is the result we want, the key is the selection of K value, the following two formula is to take the K value, the concrete derivation see the subsequent blog post.

E (i-1) * H_bar (i)
K_bar (i) =--------------------------------------------
Var_v_hat + h_bar (i) ^t * E (i-1) * H_bar (i)

E (i) = (I-k_bar (i) * H_bar (i) ^t) * E (i-1) + Q (i)//h_bar (i) calculated from the packet size of the frame

Thus, we only need to know the current frame length, send time, receive time and the state of the previous frame, you can calculate the network usage.

Next, take a look at the code:

[CPP]View
Plaincopy

2. void Overusedetector::updatekalman (int64_t T_delta,
4. Double Ts_delta,
6. uint32_t Frame_size,
8. uint32_t prev_frame_size) {
10. Const Double min_frame_period = Updateminframeperiod (Ts_delta);
12. const Double drift = Currentdrift ();
14. //Compensate for Drift
16. Const Double t_ts_delta = t_delta-ts_delta/drift; //i.e. d (i)
18. double Fs_delta = static_cast<double> (frame_size)-prev_frame_size;
22. //Update the Kalman filter
24. Const Double scale_factor = min_frame_period/(1000.0/30.0);
26. E_[0][0] + = process_noise_[0] * scale_factor;
28. E_[1][1] + = process_noise_[1] * scale_factor;
32. if (Hypothesis_ = = kbwoverusing && offset_ < prev_offset_) | |
34. (Hypothesis_ = = kbwunderusing && offset_ > Prev_offset_)) {
36. E_[1][1] + = ten * process_noise_[1] * scale_factor;
38. }
42. const Double h[2] = {Fs_delta, 1.0}; //IE H_bar
44. const Double eh[2] = {E_[0][0]*h[0] + e_[0][1]*h[1],
46. E_[1][0]*h[0] + e_[1][1]*h[1]};
50. const Double residual = t_ts_delta-slope_*h[0]-offset_; //That is Z (i), slope is 1/c
54. Const BOOL stable_state =
56. (Bwe_min (Num_of_deltas_) * FABSF (offset_) < threshold_);
58. //We try to filter out very late frames. For instance periodic key
60. //Frames doesn ' t fit the Gaussian model well.
62. if (FABSF (residual) < 3 * sqrt (var_noise_)) {
64. Updatenoiseestimate (residual, min_frame_period, stable_state);
66. } Else {
68. Updatenoiseestimate (3 * sqrt (var_noise_), Min_frame_period, stable_state);
70. }
74. Const Double denom = var_noise_ + h[0]*eh[0] + h[1]*eh[1];
78. const Double k[2] = {Eh[0]/denom,
80. EH[1]/denom}; //IE K_bar
84. const Double ikh[2][2] = {{1.0-k[0]*h[0],-k[0]*h[1]},
86. {-k[1]*h[0], 1.0-k[1]*h[1]}};
88. Const Double e00 = e_[0][0];
90. Const Double e01 = e_[0][1];
94. //Update State
96. E_[0][0] = e00 * Ikh[0][0] + e_[1][0] * ikh[0][1];
98. E_[0][1] = E01 * Ikh[0][0] + e_[1][1] * ikh[0][1];
100. E_[1][0] = e00 * Ikh[1][0] + e_[1][0] * ikh[1][1];
102. E_[1][1] = E01 * Ikh[1][0] + e_[1][1] * ikh[1][1];
106. //covariance matrix, must be positive semi-definite
108. ASSERT (E_[0][0] + e_[1][1] >= 0 &&
110. E_[0][0] * e_[1][1]-e_[0][1] * E_[1][0] >= 0 &&
112. E_[0][0] >= 0);
118. Slope_ = Slope_ + k[0] * residual; //1/c
120. prev_offset_ = offset_;
122. offset_ = offset_ + k[1] * residual; //theta_hat (i)
126. Detect (Ts_delta);
128. }

[CPP]View
Plaincopy

2. Bandwidthusage overusedetector::D etect (double ts_delta) {
4. if (Num_of_deltas_ < 2) {
6. return kbwnormal;
8. }
10. Const Double T = bwe_min (num_of_deltas_) * offset_; //IE gamma_1
12. if (FABSF (T) > Threshold_) {
14. if (offset_ > 0) {
16. if (time_over_using_ = =-1) {
18. //Initialize the timer. Assume that we ' ve been
20. //over-using half of the time since the previous
22. //Sample.
24. Time_over_using_ = TS_DELTA/2;
26. } Else {
28. //Increment timer
30. Time_over_using_ + = Ts_delta;
32. }
34. over_use_counter_++;
36. if (Time_over_using_ > Koverusingtimethreshold //koverusingtimethreshold is gamma_2, gamama_3=1
38. && over_use_counter_ > 1) {
40. if (offset_ >= prev_offset_) {
42. Time_over_using_ = 0;
44. Over_use_counter_ = 0;
46. Hypothesis_ = kbwoverusing;
48. }
50. }
52. } Else {
54. Time_over_using_ =-1;
56. Over_use_counter_ = 0;
58. Hypothesis_ = kbwunderusing;
60. }
62. } Else {
64. Time_over_using_ =-1;
66. Over_use_counter_ = 0;
68. Hypothesis_ = Kbwnormal;
70. }
72. return hypothesis_;
74. }

Reference Documentation:

1. Http://www.swarthmore.edu/NatSci/echeeve1/Ref/Kalman/ScalarKalman.html
2. http://tools.ietf.org/html/draft-alvestrand-rtcweb-congestion-02

The adaptive algorithm of bandwidth in WEBRTC