Update smoothed bitrate.

webrtc/common_audio/smoothing_filter.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 32 matching lines @@
     } else {
       initialized_ = true;
       filter_.UpdateBase(exp(1.0f / time_constant_ms_));
     }
   }
 
   // The filter will do the following:
   //   float alpha = pow(base, last_update_time_ms_ - now_ms);
   //   filtered_ = alpha * filtered_ + (1 - alpha) * sample;
   filter_.Apply(static_cast<float>(last_sample_time_ms_ - now_ms), sample);
+  last_sample_ = sample;
   last_sample_time_ms_ = now_ms;
 }
 
 rtc::Optional<float> SmoothingFilterImpl::GetAverage() const {
   float value = filter_.filtered();
-  return value == rtc::ExpFilter::kValueUndefined ? rtc::Optional<float>()
-                                                  : rtc::Optional<float>(value);
+  if (value == rtc::ExpFilter::kValueUndefined)
+    return rtc::Optional<float>();
+  int64_t now_ms = clock_->TimeInMilliseconds();
+  return rtc::Optional<float>(

[minyue-webrtc, 2016/12/01 11:32:50]

I like the idea of making the query of average time dependent. But is this
mathematically rigorous? It feels to me that we use exponential filter when we
add sample and use another filter when we query the average

+      value -
+      (value - last_sample_) *
+          (1 - exp((last_sample_time_ms_ - now_ms) / time_constant_ms_)));
 }
 
 void SmoothingFilterImpl::SetTimeConstantMs(int time_constant_ms) {
   time_constant_ms_ = time_constant_ms;
   filter_.UpdateBase(exp(1.0f / time_constant_ms_));
 }
 
 }  // namespace webrtc