webrtc gcc详解

webrtc的gcc算法(Google Congestion Control)，貌似国内很多文章都没有细讲，原理是怎么样的，具体怎么进行计算的。这里详解一下gcc。

gcc算法，主要涉及到：

• 拥塞控制的关键信息和公式

• 卡曼滤波算法

• gcc如何使用卡曼滤波算法

因为知识点有点多，文章有点长，如果感兴趣但不能一次读完，可以先收藏后，有空慢慢看。

1. 前言

对于拥塞控制，webrtc的方案之一是gcc(Google Congestion Control)。具体做法是，接收端监控两个数据，并反馈给发送端。

• 丢包率: 接收端计算出丢包率，定期发送rtcp rr报文(内有丢包率)给发送端，发送端通过丢包率的大小来决定是否降低编码的bitrate；

• 基于卡曼滤波的带宽预测: 接收端预测出当前发送端到接收端的带宽，接收端再发送rtcp remb报文(内带有预测带宽)给发送端，发送端根据该预测带宽调整编码的bitrate；

基于丢包率来调整动态编码，是比较简单，很多厂家经常在sfu服务的进行调整，如：如果不是长肥型网络，在丢包率<30%的情况下，rtcp rr中的丢包率和丢包总数欺骗性的填写0，这样发送端(尤其是web端)就不会轻易的降低bitrate，到达测试的良好效果。

但是基于卡曼滤波的带宽预测，就比较复杂，本文主要讲解这部分的原理和实现。

2. 拥塞基础信息与公式

延时是如何测量出来的: 定义报文到达的时间为t(i)，报文中的时间戳为T(i)。

那么定义延时: 

d(i) = t(i)-t(i-1)-(T(i)-T(i-1))

在带宽容量C的链路上，传输frame size为L的数据，需要的时间是: ts = L/C

我们对到达时间的间隔进行建模:

         L(i)-L(i-1)d(i) = -------------- + w(i) = dL(i)/C+w(i)             C

上面的公式，i为某个时刻，i-1为上一个时刻。

L(i): 是i时刻接收到的报文长度(这里一般是指某个固定时段接收到的报文size总和)

L(i-1): 是对于i的上一个时刻的报文长度(上一个固定时段收到的报文size总和)

C: 为链路容量带宽；

W(i): 作为一个高斯白噪声，这个参数非常重要。

d(i)：是i时刻的延时

划重点：

如果链路使用超载，w(i)增加；

如果链路比较空，w(i)减小;

也就是说，上面两个公式就是预测和估计w(i)是增加了，还是减小了。

总结，关键公式就是这两个：

公式1(测量)：d(i) = t(i)-t(i-1)-(T(i)-T(i-1))公式2(估计)：                 L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

公式1: 两个时刻的接收报文的本地时间差值，再减去两个时刻的rtp报文中携带的时间戳的差值，结果等于延时(本地时间与rtp报文中时间戳的单位不一致，需要自己转换一致后再计算)。也就是说d(i)是个测量值，每次收到新的一批报文都能测算得出来对应的延时d(i)，所以这里强调d(i)是个测量值。

公式2: 在公式2中，dL(i)是两个时刻收到报文长度的差值，这个也是每收到一批报文后能测算出来的，dL(i)也是个测量值。1/C是个估计值，C是估计的带宽容量，w(i)也是一个估计值。注意，公式左边的d_est(i)也是表示i时刻的延时，不过这个延时是通过右边的估计值计算出来的，也就是这个计算出来的d_est(i)是一个估计值。

最后，我们得到，每个i时刻的测量值d(i)，和测量值dL(i)，要预测出1/C(i)和w(i)，这就是我们的目标。

强调: w(i)增加，表示链路超载；w(i)减小，表示链路轻负荷。

卡曼滤波就是要预测出1/C(i)和w(i)，并根据根据w(i)是增加或减小，来决定预测带宽是增加还是减小。

小白部分: 既然有了公式1和2，为啥不每次直接计算出延时和带宽的关系，为啥还要引入卡曼滤波算法，弄这么复杂。原因主要是，凡是测试的数据，都会出现测不准，或者有偶尔发生的错误数据(术语叫作噪声)，比如某时刻发生抖动，仅仅一批数据产生巨大的延时，但是其实网络是好的，滤波的作用就是过滤出一些无效，错误数据的影响。

先记住这两个公式，后面先打断一下，简单介绍一下卡曼滤波算法。

3. 卡曼滤波算法和示例

针对测试数据，有测试不准确的情况，所以需要在测试数据和估计数据之间进行权衡，卡曼滤波算法就是一个线性的滤波估计算法。

卡曼滤波的5个公式如下(如果看公式有不理解的地方，后面会有个经典的例子，让你理解如何使用这5个公式)：

一共5个方程，如上图，左边两个是时间更新方程(预测)，右边是测量更新方程(更新/纠正)。

如果第一次接触卡曼滤波算法，可以先熟悉算法，先不研究这5个公式的由来(数学推导)，可以作为使用者，只要知道每个变量代表什么意思，如何代入方程，就能满足基础的需求。

头两个预测方程中的参数含义:

A: 状态转移矩阵，就是上一个状态的x变量如何能推导出下一个状态的值。

B：是将输入转换为状态的矩阵；

Q：过程激励噪声协方差（系统过程的协方差）。

后三个测量更新方程的参数含义:

R: 测量噪声协方差。滤波器实际实现时，测量噪声协方差 R一般可以观测得到，是滤波器的已知条件，用户可以根据自己的情况自己设定。

因为公式较多，参数也较多，不容易让人理解，下面举个经典的例子，让你熟悉这些公式和参数。

3.1 卡曼滤波例子(自由落体运动)

假设一个实心球从高空落下，正常来说，我们是能通过速度，加速度g(自由落体加速度9.8米/s)，能计算出某个时刻该球的行驶距离速度。

但是因为有空气阻力，或者外界干扰(刮风什么的)，实际的速度和距离就不能自己计算出来，需要进行测试。假设实心球自己是能测试出距离和速度的，但是测试仪得出的值可能有误差，需要和计算出来的距离和速度进行折中。

卡曼滤波算法，就是对估计值与测试值进行折中，寻找出真相值的过程。

距离，速度和加速度在时间t上的关系：

s(i) = s(i-1) + v(i-1)*t + 0.5*g*t^2v(i) = v(i-1) + g*t

用线性代数的矩阵来表示就是:

上面这个式子就是卡曼滤波公式1: 

A就是: 

Bu就是:

卡曼滤波的公式2:

其中P是一个协方差矩阵，可以自己初始化一下，协方差矩阵是一个对角矩阵(后续随着数据的输入，P会不断通过公式2和公式5自我更新):

Q是过程激励噪声协方差，表示噪声，可以自己初始化:

卡曼滤波公式3:

其中H是状态变量与测试变量的转换矩阵，因为本例是完全对应的关系，所以这里的H是一个单位矩阵。

R是误差，这里是两个参数s和v，假设测试参数还是比较准，R可以适当的设置小一些(自己更具情况设置)：

这样卡曼滤波参数K就可以通过P，H，R三个参数计算出来了。

卡曼滤波公式4:

通过公式3，已经计算出K，参数Z是测试值，本例中Z就是一个向量包含距离和速度(s, v)，式子右边的X就是公式1中计算出来的预测值向量(s, v)

公式4非常重要，通过这个公式，对计算估计出来的值，与测试的值进行折中，得出尽可能接近真实的值。

卡曼滤波公式5:

I是单位矩阵，K是公式3计算出来的卡曼滤波增益参数，H是状态变量与测试变量的转换矩阵(本例中是个单位矩阵)，式子右边的P是公式2预测的P矩阵。

通过公式5的计算，对P协方差矩阵进行更新。

对上面的5个公式解释后，这里用python进行模拟，代码如下:​​​​​​​

import numpy as npdelta_t = 1 #每次变化是1秒a = 9.8 #重力加速度g# 状态迁移矩阵AA = np.array([[1, delta_t],            [0, 1]])# 协方差矩阵P = np.array([[1, 0.5],              [0.5, 1]])# 预测值与测试值的变换矩阵H = np.array([[1, 0],              [0, 1]])# 过程激励噪声协方差Q = np.array([[0.05, 0.01],              [0.01, 0.05]])# 观测噪声协方差R = np.array([[0.01, 0.01],              [0.01, 0.01],])# 单位矩阵I = np.eye(2)# 每1秒的测试值，第一项是距离，第二项是速度messure_list = np.array([[2.9,  8.8],                        [19.1,  18.1],                        [44.1,  28.9],                        [84.9,  38.7],                        [134,  50],                        [193.4,  62.3],                        [266.1,  72.1],                        [348.6,  83.4],                        [442.4,  95.7],                        [548,  105.5]])# 卡曼滤波公式1: 状态迁移def StatePridict(pos, speed):    x_vector = np.array([[pos], [speed]])    b_u = np.array([[0.5*a*delta_t*delta_t], [a*delta_t]])    result = np.dot(A, x_vector) + b_u    return result# 卡曼滤波公式3: 计算卡曼滤波增益参数Kdef UpdateK():    up_item = np.dot(P, H.transpose())    down_item = np.dot(np.dot(H, P), H.transpose()) + R    inv_item = np.linalg.inv(down_item)    return np.dot(up_item, inv_item)i = 0predict_array = np.array([[],[]])pos_predict = 0speed_predict = 0for z in messure_list:    # 方程1: 状态预测公式(根据距离，速度，时间公式推导)    next = StatePridict(pos_predict, speed_predict)    print("predict next:", next)    # 方程2: 协方差矩阵预测公式    P = np.dot(np.dot(A, P), np.transpose(A)) + Q    print("predict P:", P)    # 方程3: 卡曼滤波增益计算公式    K = UpdateK()    print("update K:", K)    # 方程4: 状态更新公式    messure_item = z.reshape(-1, 1)    print("messure item(", i, "):", messure_item, "shape:", messure_item.shape)    deviation = messure_item - np.dot(H, next)    print("deviation:", deviation)    next = next + np.dot(K, deviation)    predict_array = np.append(predict_array, next)    pos_predict = next[0][0]    speed_predict = next[1][0]    print("update next state pos:", pos_predict, "velocity:", speed_predict)    # 方程5: 协方差更新公司    P = np.dot((I - K * H), P)    print("update P:", P)    i = i + 1    print("")

把这个程序跑起来，观测各个参数的变化过程，仔细阅读，慢慢就理解这5个公式怎么使用。

4. GCC应用卡曼滤波算法

在第2章中，回忆一下这两个公式：​​​​​​​

公式1(测量)：d(i) = t(i)-t(i-1)-(T(i)-T(i-1))公式2(估计)：                 L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

每个i时刻的测量值d(i)，和测量值dL(i)，要预测出1/C(i)和w(i)，这就是我们的目标。

w(i)增加超过一个阈值，表示链路超载，w(i)减小了，表示链路轻负荷。

卡曼滤波就是要预测出1/C(i)和w(i)，并根据根据w(i)是增加或减小，来决定预测带宽是增加还是减小。本节介绍如何预测1/C(i)和w(i)。

回忆一下卡曼滤波的5个公式:

这里，因为向量中的两个参数[1/C w]，自身是没法推导自己，所以卡曼滤波的公式1和公式2就省略了，或者说A矩阵就是个单位矩阵，Bu是0，这样预测后的结果还是自己。

这样就直接构造公式3:

X就是[1/C    W]向量的转置

H矩阵= [delta_len    1]，delta_len就是两次不同时刻统计收到报文长度的差值。

R是误差，在本例中可以自己设置，在webrtc源码实现中通过UpdateNoiseEstimate函数来更新获取(为了突出主线，这里先省略)。

这样公式3的K就计算出来了。

公式4，更新估计值，

Z就是i时刻的测试数据的延时delay(i)，通过d(i) = t(i)-t(i-1)-(T(i)-T(i-1))得到i时刻的延时。

公式5，

等式右边的P是公式2中计算出来的P，因为公式1和2都省略，所以这里值需要确认H就可以

H = [delta_len     1].T

I是单位矩阵。

因为K在公式3中已经计算出来，所以P很容易计算出来。

4.1 python仿真gcc的卡曼滤波

delay_array：表示收到报文测试出来的延时集合

deltalen_array：表示收到报文长度差值的集合

两者作为测试数据，数组下标是一一对应的。​​​​​​​

import numpy as np# d(i) = dL(i)/C + m(i) +v(i) 关键点: 过载的情况，m(i)增加; 轻载的情况，m(i)减小# theta_bar(i) = [1/C(i)  m(i)]^T 其中，带宽C(i)可以设置个初始值，m(i)也设置一个初始值, 后面这两个值就是根据每一次的测试数据来进行预测；# h_bar(i) = [dL(i) 1]^T 其中dL(i)是每次长度变化值，是测试的输入# 方程1: 状态预测公式(根据报文差，带宽公式推导)# 本例没有[1/C(i) m(i)]这个向量自己预测自己的公式，这个公式省略掉，或则说就是自己等于自己# 方程2: 协方差矩阵预测公式# 同方程1，因为没有预测公式，这个方程也省略掉；# 方程3: 卡曼滤波增益计算公式#                              P_(i) * h_bar(i)#     K(i) = --------------------------------------------#                  var_v_hat + h_bar(i)^T * P_(i) * h_bar(i)# 其中P_(i)是协方差矩阵，见方程2; var_v_hat是误差，自己可以初始化一个# 方程4: 状态更新公式# d(i) = h_bar(i)^T * theta_bar(i) + v(i) 两个矩阵的点乘，就是dL(i)/C + m(i)这个式子，v(i)是一个噪声参数(可以初始设定一个较小的值)# z(i) = D(i) - d(i) 这里的D(i)是延时的测试数据，也就是报文来的差值，d(i)是预测数据# z(i) = D(i) - (h_bar(i)^T * theta_bar(i-1) + v(i))# new_theta_bar(i) = theta_bar(i) + K(i) * z(i) 这个式子就是状态更新公式，更新得到新的[1/C(i) m(i)]# 方程5: 协方差更新公式# P(i) = (I - K(i) * h_bar(i)^T) * P_(i) + Q(i) 其中P(i)是协方差矩阵，Q(i)是误差delay_array = [-4.45, 3.92, -3.5, -0.29, 10.77, -6.2, 6.98, -2.75, -8.88, -0.12, 0.78, -0.32, 2.05, -1.61, 3.67, 3.93, 13.23, 51.25, 15.32, 51.05, 124.61, -14.47, 9.43, 43.11, -10.98, 27.03, 34.31, 52.31, 132.39, -9.93, -1.63, 20.47, 54.73, 12.43, 19.86, 0.6, 78.59, -0.2, 35.04, 8.0, 68.9, 6.65, 82.35, 25.6, 108.01, -1.68, 42.52, 7.66, 82.26, 1.68, -0.39, 65.92, 15.35, 77.69, -2.38, -4.94, 9.82, -12.88, 132.41, -0.57, 81.74, 0.13, 33.81, -16.92, -18.68, -1.04, -56.98, 27.08, 0.44, -10.58, -23.03, 23.82, 36.17, -47.1, -140.67, 28.14, -30.56, -72.59, -21.58, -45.59, -87.41, 12.47, 1.0, -3.05, -37.41, -32.05, 22.89, 7.52, 11.13, 34.15, 88.15, -42.39, -2.78, -52.67, -16.58, 5.19, 55.34, 44.73, -13.97, 0.22, 7.63, 27.57, 49.72, 61.74, 18.91, 48.0, -24.09, -6.95, -50.06, 217.24, -62.06, -2.07, 5.83, -3.88, -6.4, 4.35, 39.61, -7.67, 5.65, 9.45, 70.02, -48.47, 35.76, 8.69, -6.4, -4.5, -2.26, -21.2, -53.22, -11.8, 12.25, -8.98, -2.94, -43.99, 1.12, -0.04, -8.08, 14.05, -31.01, -80.63, 94.82, -25.58, -58.55, 47.87, -67.36, 17.57, 4.64, 0.1, 4.71, 7.01, -1.5, -3.25, -1.87, -22.01, 9.57, -8.71, -3.17, -2.12, -36.99, 54.74, -14.71, -8.64, -46.41, 48.79, 5.74, -14.25, -7.76, 30.98, -6.09, 43.08, 16.21, 15.78, -2.86, -63.44, 73.09, -39.69, -50.57, -14.58, -5.34, 5.39, -17.07, -28.32, -15.5, 6.03, -62.54, 1.0, 1.01, -13.52, -32.07, 75.16, -5.2, -0.91, 1.48, 41.72, -21.1, 11.13]deltalen_array = [-98.0, 170.0, -170.0, 314.0, 612.0, -926.0, 873.0, -541.0, 769.0, -1101.0, 0.0, -50.0, 50.0, 182.0, 1407.0, -1589.0, 776.0, -776.0, 55.0, -55.0, 1126.0, -1126.0, 80.0, -80.0, 305.0, -305.0, 278.0, -278.0, 1414.0, -1414.0, 2.0, -2.0, 642.0, -642.0, 387.0, -387.0, 771.0, -771.0, 352.0, -352.0, 746.0, -746.0, 776.0, -776.0, 1420.0, -1420.0, 567.0, -567.0, 923.0, -923.0, 0.0, 660.0, -660.0, 1012.0, -1012.0, 0.0, 0.0, 0.0, 1631.0, -1631.0, 890.0, -890.0, 700.0, -700.0, 0.0, 291.0, -291.0, 412.0, -412.0, 0.0, 75.0, 423.0, -27.0, -434.0, -37.0, 283.0, -115.0, -8.0, -160.0, 160.0, 0.0, -160.0, 0.0, 0.0, 484.0, -484.0, 219.0, -219.0, 0.0, 364.0, 492.0, -856.0, -160.0, 143.0, 17.0, -160.0, 853.0, -184.0, -509.0, 47.0, -47.0, 318.0, 385.0, -32.0, -671.0, 831.0, -831.0, 0.0, 0.0, 2097.0, -2097.0, 0.0, 85.0, -85.0, 0.0, 0.0, 0.0, 160.0, -160.0, 0.0, 1143.0, -983.0, 335.0, -495.0, 0.0, 194.0, -194.0, 0.0, 0.0, 0.0, -17.0, 177.0, -160.0, 0.0, 25.0, -25.0, 0.0, 335.0, 935.0, -1270.0, 941.0, -941.0, 0.0, 835.0, -835.0, 62.0, -62.0, 0.0, 0.0, 194.0, -194.0, 0.0, 0.0, 0.0, 0.0, 0.0, -17.0, 17.0, 0.0, 459.0, -459.0, 160.0, -160.0, 422.0, -422.0, 0.0, 0.0, 208.0, -208.0, 0.0, 946.0, -946.0, 0.0, 242.0, -242.0, 0.0, 0.0, 160.0, -160.0, 0.0, 0.0, 40.0, -40.0, 0.0, 0.0, 0.0, 160.0, -160.0, 320.0, 612.0, -932.0, 0.0, 0.0, 479.0, -479.0, 951.0]C = 50.0 #假设带宽C为50slope_c = 1.0/Cv = 5 #计算延时时候的噪声参数m = 0.1  #m参数，过载的情况，m增加; 轻载的情况，m减小R = 0.05P_Matrix = np.array([[100.0, 0.0],             [0.0, 1e-1]])Q = np.array([[0.05, 0.01],             [0.01, 0.05]])I = np.array([[1, 0],             [0, 1]])def GetK(delta_len, p, r):    h_bar = np.array([[delta_len], [1]])    numerator = np.dot(p, h_bar)    den = np.dot(np.dot(h_bar.T, p), h_bar)    return np.dot(numerator, np.linalg.inv(den)) + r    def DelayUpdate(k, z, delta_len):    h_bar = np.array([[delta_len], [1]])    theta_bar = np.array([[slope_c], [m]])        error = z - (np.dot(h_bar.T, theta_bar) + v)    return theta_bar + k * errordef Update_P(k, p, delta_len):    h_bar = np.array([[delta_len], [1]])    p = p + Q    return np.dot(I - np.dot(k, h_bar.T), p)index = 0for delta_len in deltalen_array:    delay = delay_array[index]    index = index + 1    K = GetK(delta_len, P_Matrix, R)    theta_bar_update = DelayUpdate(K, delay, delta_len)    P_Matrix = Update_P(K, P_Matrix, delta_len)    print("theta_bar_update:", theta_bar_update)

其中GetK函数的生成K卡曼滤波增益参数中，误差参数r是随机设置的。

实际的r是可以通过rtp报文时间戳的差值推导出来，更为精确，详细看这个函数UpdateNoiseEstimate()

4.2 gcc卡曼滤波源码部分

在函数OveruseEstimator::Update()中，

卡曼滤波公式3，计算出K:​​​​​​​

  const double h[2] = {fs_delta, 1.0};  const double Eh[2] = {E_[0][0] * h[0] + E_[0][1] * h[1],                        E_[1][0] * h[0] + E_[1][1] * h[1]};  const double denom = var_noise_ + h[0] * Eh[0] + h[1] * Eh[1];  const double K[2] = {Eh[0] / denom, Eh[1] / denom};

卡曼滤波公式4，计算出1/C，和w，在源码中slope_就是1/C, offset_就是w。residual就是误差部分，其实就是测量值和估计值的差值。​​​​​​​

// residual就是误差部分，其实就是测量值和估计值的差值// 就是python里写的：error = z - (np.dot(h_bar.T, theta_bar) + v)const double residual = t_ts_delta - slope_ * h[0] - offset_;// slope_就是1/Cslope_ = slope_ + K[0] * residual;//offset_比较关键，offset_就是w// w(i)增加，链路使用超载// w(i)减小，链路比较空offset_ = offset_ + K[1] * residual;

上面就是卡曼滤波部分，代码不多，就是原理比较复杂。

4.3 如何判断带宽增减

在4.2中已经能时刻更新offset_的值，也就是我们之前说的公式中:​​​​​​​

            L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

上面公式中的w(i)就是offset_，

• w(i)增加(也就是offset_)，链路使用超载

• w(i)减小(也就是offset_)，链路比较空

但是如何判断增加和减小多少，这个增量/减量多少认为该做带宽的增减操作呢？

如上图的m(ti)就是m(ti) = std::min(num_of_deltas, kMaxNumDeltas) * offset; 这里的offset就是w(i)

γ (ti )就是threshold_，下面是gcc源码中，函数BandwidthUsage OveruseDetector::Detect()，大于threshold_则带宽过载，小于threshold_则是带宽轻载，否则就保持原状态。​​​​​​​

BandwidthUsage OveruseDetector::Detect() {  const double T = std::min(num_of_deltas, kMaxNumDeltas)                 * offset;  if (T > threshold_) {    hypothesis_ = BandwidthUsage::kBwOverusing;  } else if (T < -threshold_) {    hypothesis_ = BandwidthUsage::kBwUnderusing;  } else {    hypothesis_ = BandwidthUsage::kBwNormal;  }}

通过Detect()返回值，判断是否变换预测带宽。

这个threshold_也是动态变化的，

根据OveruseDetector::UpdateThreshold()函数来更新:​​​​​​​

void OveruseDetector::UpdateThreshold(){  // k_up_(0.0087),  // k_down_(0.039),  const double k = fabs(modified_offset) < threshold_ ?                     k_down_ : k_up_;  const int64_t kMaxTimeDeltaMs = 100;  int64_t time_delta_ms = std::min(now_ms - last_update_ms_,                                kMaxTimeDeltaMs);  threshold_ += k * (fabs(modified_offset) - threshold_)                    * time_delta_ms;  threshold_ = rtc::SafeClamp(threshold_, 6.f, 600.f);  last_update_ms_ = now_ms;}

这里有两个关键的参数k_up_(0.0087), k_down_(0.039)。

k_down_明显要比k_up_大不少，其含义就是预测带宽降低检测的时候，需要更加敏感一些，或者说是需要降低快一些；相反，带宽增减就需要慢一点，稳当一点，保证流畅性。

不少公司都对k_down_和k_up_的参数进行优化，来满足自己动态码率的需求。

5. 总结

最后总结一下，gcc的动态码率依赖两个东西：

• 丢包率

  丢包率在接收端计算后，通过RTCP rr报文发送给发送端，丢包率>5%，默认就要开始降低编码bitrate；

  如果是sfu服务器模式，sfu代码中可以把rtcp rr中的丢包率和丢包总数根据自定义条件填写0，这样发送端就不会动态调整编码bitrate，达到某些预期的效果

• 接收端基于延时的卡曼滤波带宽预测

    1) 通过测试delay，和预测的delay来确定卡曼滤波模型，根据模型推导出下一步带宽预测offset。​​​​​​​

公式1(测量)：d(i) = t(i)-t(i-1)-(T(i)-T(i-1))公式2(估计)：                 L(i)-L(i-1)d_est(i) = ------------ + w(i) = dL(i)/C+w(i)                C

    2) 得到卡曼滤波的变换值offset(也就是上面的w(i))，在根据计算出的threshold，用offset与threshold比较，决定预测带宽应该增加，减少还是不变。