Change TWCC send interval to reduce overhead on low BW situations.

webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h

 /*
  *  Copyright (c) 2015 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.
  */
 
 #ifndef WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_REMOTE_ESTIMATOR_PROXY_H_
 #define WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_REMOTE_ESTIMATOR_PROXY_H_
 
 #include <map>
+#include <memory>
 #include <vector>
 
 #include "webrtc/base/criticalsection.h"
+#include "webrtc/base/ratetracker.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 
 namespace webrtc {
 
+class BitrateController;
 class Clock;
 class PacketRouter;
 namespace rtcp {
 class TransportFeedback;
 }
 
 // Class used when send-side BWE is enabled: This proxy is instantiated on the
 // receive side. It buffers a number of receive timestamps and then sends
 // transport feedback messages back too the send side.
 
 class RemoteEstimatorProxy : public RemoteBitrateEstimator {
  public:
-  RemoteEstimatorProxy(Clock* clock, PacketRouter* packet_router);
+  RemoteEstimatorProxy(Clock* clock,
+                       PacketRouter* packet_router,
+                       BitrateController* bitrate_controller);

[stefan-webrtc, 2016/10/26 14:45:16]

I'm not sure I like this dependency... We can't know if the receiver is also a
sender, and if it's a pure receiver it won't have a valid bandwidth estimate on
its uplink. In that case I think it's better to base this on the bitrate
received?

[michaelt, 2016/10/27 15:15:44]

But if we use bitrate received we assume that we are in a symmetrical network
witch is not necessary the case.

[stefan-webrtc, 2016/10/31 08:54:36]

Right, when the client is receive-only we have to decide on something. Either we
base it on the receive bitrate or we hard code it. WDYT?

If we want the RemoteEstimatorProxy to have access to the send bandwidth I think
I'd prefer to do it through an observer interface, for instance BitrateObserver
(see webrtc/modules/bitrate_controller/include/bitrate_controller.h).

[michaelt, 2016/10/31 13:03:15]

For this CL i would use a hard coded rate on the receive-only case.

I discover some problems on using BitrateObserver.
1. BitrateObserver seams to be deprecated.
2. It seams that in the current impl. there is no way to inform multiple
BitrateObserver.

What do you think about set the current send bandwidth in RemoteEstimatorProxy
with a function "OnBitrateChanged" called in the function
"MaybeTriggerOnNetworkChanged" in the CongestionController ?   

[stefan-webrtc, 2016/10/31 14:04:19]

Constant rate for receive only and using OnBitrateChanged() both sound good to
me. 

[michaelt, 2016/11/02 10:10:06]

Done.

   virtual ~RemoteEstimatorProxy();
 
   void IncomingPacketFeedbackVector(
       const std::vector<PacketInfo>& packet_feedback_vector) override;
   void IncomingPacket(int64_t arrival_time_ms,
                       size_t payload_size,
                       const RTPHeader& header) override;
   void RemoveStream(uint32_t ssrc) override {}
   bool LatestEstimate(std::vector<unsigned int>* ssrcs,
                       unsigned int* bitrate_bps) const override;
   void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override {}
   void SetMinBitrate(int min_bitrate_bps) override {}
   int64_t TimeUntilNextProcess() override;
   void Process() override;
 
-  static const int kDefaultProcessIntervalMs;
+  static const int kMinSendIntervalMs;
+  static const int kMaxSendIntervalMs;
+  static const int kMinPacketCountRecievedBitrate;

[stefan-webrtc, 2016/10/26 14:45:16]

Received

[michaelt, 2016/10/27 15:15:44]

Removed this const since its not used anymore. 

   static const int kBackWindowMs;
 
  private:
   void OnPacketArrival(uint16_t sequence_number, int64_t arrival_time)
       EXCLUSIVE_LOCKS_REQUIRED(&lock_);
   bool BuildFeedbackPacket(rtcp::TransportFeedback* feedback_packet);
 
   Clock* const clock_;
   PacketRouter* const packet_router_;
   int64_t last_process_time_ms_;
 
   rtc::CriticalSection lock_;
 
   uint32_t media_ssrc_ GUARDED_BY(&lock_);
   uint8_t feedback_sequence_ GUARDED_BY(&lock_);
   SequenceNumberUnwrapper unwrapper_ GUARDED_BY(&lock_);
   int64_t window_start_seq_ GUARDED_BY(&lock_);
   // Map unwrapped seq -> time.
   std::map<int64_t, int64_t> packet_arrival_times_ GUARDED_BY(&lock_);
+  BitrateController* bitrate_controller_;
 };
 
 }  // namespace webrtc
 
 #endif  //  WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_REMOTE_ESTIMATOR_PROXY_H_